blob: 987a165ede2686ef8de37b7e72a1426e40b9ed25 [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>
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +010031#include <linux/syscore_ops.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Thomas Renninger6f4f2722010-04-20 13:17:36 +020033#include <trace/events/power.h>
34
Linus Torvalds1da177e2005-04-16 15:20:36 -070035/**
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 */
Dmitry Monakhove77b89f2009-10-05 00:38:55 +040044static DEFINE_PER_CPU(char[CPUFREQ_NAME_LEN], 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.
Mathieu Desnoyers395913d2009-06-08 13:17:31 -040064 * - Lock should not be held across
65 * __cpufreq_governor(data, CPUFREQ_GOV_STOP);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -080066 */
Tejun Heof1625062009-10-29 22:34:13 +090067static DEFINE_PER_CPU(int, cpufreq_policy_cpu);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -080068static DEFINE_PER_CPU(struct rw_semaphore, cpu_policy_rwsem);
69
70#define lock_policy_rwsem(mode, cpu) \
Amerigo Wang226528c2010-03-04 03:23:36 -050071static int lock_policy_rwsem_##mode \
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -080072(int cpu) \
73{ \
Tejun Heof1625062009-10-29 22:34:13 +090074 int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu); \
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -080075 BUG_ON(policy_cpu == -1); \
76 down_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu)); \
77 if (unlikely(!cpu_online(cpu))) { \
78 up_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu)); \
79 return -1; \
80 } \
81 \
82 return 0; \
83}
84
85lock_policy_rwsem(read, cpu);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -080086
87lock_policy_rwsem(write, cpu);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -080088
Amerigo Wang226528c2010-03-04 03:23:36 -050089static void unlock_policy_rwsem_read(int cpu)
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -080090{
Tejun Heof1625062009-10-29 22:34:13 +090091 int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -080092 BUG_ON(policy_cpu == -1);
93 up_read(&per_cpu(cpu_policy_rwsem, policy_cpu));
94}
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -080095
Amerigo Wang226528c2010-03-04 03:23:36 -050096static void unlock_policy_rwsem_write(int cpu)
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -080097{
Tejun Heof1625062009-10-29 22:34:13 +090098 int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -080099 BUG_ON(policy_cpu == -1);
100 up_write(&per_cpu(cpu_policy_rwsem, policy_cpu));
101}
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800102
103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104/* internal prototypes */
Dave Jones29464f22009-01-18 01:37:11 -0500105static int __cpufreq_governor(struct cpufreq_policy *policy,
106 unsigned int event);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800107static unsigned int __cpufreq_get(unsigned int cpu);
David Howells65f27f32006-11-22 14:55:48 +0000108static void handle_update(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
110/**
Dave Jones32ee8c32006-02-28 00:43:23 -0500111 * Two notifier lists: the "policy" list is involved in the
112 * validation process for a new CPU frequency policy; the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 * "transition" list for kernel code that needs to handle
114 * changes to devices when the CPU clock speed changes.
115 * The mutex locks both lists.
116 */
Alan Sterne041c682006-03-27 01:16:30 -0800117static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700118static struct srcu_notifier_head cpufreq_transition_notifier_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
Cesar Eduardo Barros74212ca2008-02-16 08:41:24 -0200120static bool init_cpufreq_transition_notifier_list_called;
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700121static int __init init_cpufreq_transition_notifier_list(void)
122{
123 srcu_init_notifier_head(&cpufreq_transition_notifier_list);
Cesar Eduardo Barros74212ca2008-02-16 08:41:24 -0200124 init_cpufreq_transition_notifier_list_called = true;
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700125 return 0;
126}
Linus Torvaldsb3438f82006-11-20 11:47:18 -0800127pure_initcall(init_cpufreq_transition_notifier_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
129static LIST_HEAD(cpufreq_governor_list);
Dave Jones29464f22009-01-18 01:37:11 -0500130static DEFINE_MUTEX(cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
Dave Jones7d5e3502006-02-02 17:03:42 -0500132struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133{
134 struct cpufreq_policy *data;
135 unsigned long flags;
136
Mike Travis7a6aedf2008-03-25 15:06:53 -0700137 if (cpu >= nr_cpu_ids)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 goto err_out;
139
140 /* get the cpufreq driver */
141 spin_lock_irqsave(&cpufreq_driver_lock, flags);
142
143 if (!cpufreq_driver)
144 goto err_out_unlock;
145
146 if (!try_module_get(cpufreq_driver->owner))
147 goto err_out_unlock;
148
149
150 /* get the CPU */
Mike Travis7a6aedf2008-03-25 15:06:53 -0700151 data = per_cpu(cpufreq_cpu_data, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
153 if (!data)
154 goto err_out_put_module;
155
156 if (!kobject_get(&data->kobj))
157 goto err_out_put_module;
158
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 return data;
161
Dave Jones7d5e3502006-02-02 17:03:42 -0500162err_out_put_module:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 module_put(cpufreq_driver->owner);
Dave Jones7d5e3502006-02-02 17:03:42 -0500164err_out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Dave Jones7d5e3502006-02-02 17:03:42 -0500166err_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 return NULL;
168}
169EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
170
Dave Jones7d5e3502006-02-02 17:03:42 -0500171
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172void cpufreq_cpu_put(struct cpufreq_policy *data)
173{
174 kobject_put(&data->kobj);
175 module_put(cpufreq_driver->owner);
176}
177EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
178
179
180/*********************************************************************
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 * EXTERNALLY AFFECTING FREQUENCY CHANGES *
182 *********************************************************************/
183
184/**
185 * adjust_jiffies - adjust the system "loops_per_jiffy"
186 *
187 * This function alters the system "loops_per_jiffy" for the clock
188 * speed change. Note that loops_per_jiffy cannot be updated on SMP
Dave Jones32ee8c32006-02-28 00:43:23 -0500189 * systems as each CPU might be scaled differently. So, use the arch
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 * per-CPU loops_per_jiffy value wherever possible.
191 */
192#ifndef CONFIG_SMP
193static unsigned long l_p_j_ref;
194static unsigned int l_p_j_ref_freq;
195
Arjan van de Ven858119e2006-01-14 13:20:43 -0800196static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197{
198 if (ci->flags & CPUFREQ_CONST_LOOPS)
199 return;
200
201 if (!l_p_j_ref_freq) {
202 l_p_j_ref = loops_per_jiffy;
203 l_p_j_ref_freq = ci->old;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200204 pr_debug("saving %lu as reference value for loops_per_jiffy; "
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530205 "freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 }
207 if ((val == CPUFREQ_PRECHANGE && ci->old < ci->new) ||
208 (val == CPUFREQ_POSTCHANGE && ci->old > ci->new) ||
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -0700209 (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530210 loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
211 ci->new);
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200212 pr_debug("scaling loops_per_jiffy to %lu "
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530213 "for frequency %u kHz\n", loops_per_jiffy, ci->new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 }
215}
216#else
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530217static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
218{
219 return;
220}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221#endif
222
223
224/**
Dave Jonese4472cb2006-01-31 15:53:55 -0800225 * cpufreq_notify_transition - call notifier chain and adjust_jiffies
226 * on frequency transition.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 *
Dave Jonese4472cb2006-01-31 15:53:55 -0800228 * This function calls the transition notifiers and the "adjust_jiffies"
229 * function. It is called twice on all CPU frequency changes that have
Dave Jones32ee8c32006-02-28 00:43:23 -0500230 * external effects.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 */
232void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
233{
Dave Jonese4472cb2006-01-31 15:53:55 -0800234 struct cpufreq_policy *policy;
235
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 BUG_ON(irqs_disabled());
237
238 freqs->flags = cpufreq_driver->flags;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200239 pr_debug("notification %u of frequency transition to %u kHz\n",
Dave Jonese4472cb2006-01-31 15:53:55 -0800240 state, freqs->new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
Mike Travis7a6aedf2008-03-25 15:06:53 -0700242 policy = per_cpu(cpufreq_cpu_data, freqs->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 switch (state) {
Dave Jonese4472cb2006-01-31 15:53:55 -0800244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 case CPUFREQ_PRECHANGE:
Dave Jones32ee8c32006-02-28 00:43:23 -0500246 /* detect if the driver reported a value as "old frequency"
Dave Jonese4472cb2006-01-31 15:53:55 -0800247 * which is not equal to what the cpufreq core thinks is
248 * "old frequency".
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 */
250 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
Dave Jonese4472cb2006-01-31 15:53:55 -0800251 if ((policy) && (policy->cpu == freqs->cpu) &&
252 (policy->cur) && (policy->cur != freqs->old)) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200253 pr_debug("Warning: CPU frequency is"
Dave Jonese4472cb2006-01-31 15:53:55 -0800254 " %u, cpufreq assumed %u kHz.\n",
255 freqs->old, policy->cur);
256 freqs->old = policy->cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 }
258 }
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700259 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
Alan Sterne041c682006-03-27 01:16:30 -0800260 CPUFREQ_PRECHANGE, freqs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
262 break;
Dave Jonese4472cb2006-01-31 15:53:55 -0800263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 case CPUFREQ_POSTCHANGE:
265 adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200266 pr_debug("FREQ: %lu - CPU: %lu", (unsigned long)freqs->new,
Thomas Renninger6f4f2722010-04-20 13:17:36 +0200267 (unsigned long)freqs->cpu);
268 trace_power_frequency(POWER_PSTATE, freqs->new, freqs->cpu);
Thomas Renninger25e41932011-01-03 17:50:44 +0100269 trace_cpu_frequency(freqs->new, freqs->cpu);
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700270 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
Alan Sterne041c682006-03-27 01:16:30 -0800271 CPUFREQ_POSTCHANGE, freqs);
Dave Jonese4472cb2006-01-31 15:53:55 -0800272 if (likely(policy) && likely(policy->cpu == freqs->cpu))
273 policy->cur = freqs->new;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 break;
275 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276}
277EXPORT_SYMBOL_GPL(cpufreq_notify_transition);
278
279
280
281/*********************************************************************
282 * SYSFS INTERFACE *
283 *********************************************************************/
284
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700285static struct cpufreq_governor *__find_governor(const char *str_governor)
286{
287 struct cpufreq_governor *t;
288
289 list_for_each_entry(t, &cpufreq_governor_list, governor_list)
Dave Jones29464f22009-01-18 01:37:11 -0500290 if (!strnicmp(str_governor, t->name, CPUFREQ_NAME_LEN))
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700291 return t;
292
293 return NULL;
294}
295
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296/**
297 * cpufreq_parse_governor - parse a governor string
298 */
Dave Jones905d77c2008-03-05 14:28:32 -0500299static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 struct cpufreq_governor **governor)
301{
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700302 int err = -EINVAL;
303
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 if (!cpufreq_driver)
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700305 goto out;
306
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 if (cpufreq_driver->setpolicy) {
308 if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
309 *policy = CPUFREQ_POLICY_PERFORMANCE;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700310 err = 0;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530311 } else if (!strnicmp(str_governor, "powersave",
312 CPUFREQ_NAME_LEN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 *policy = CPUFREQ_POLICY_POWERSAVE;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700314 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 }
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700316 } else if (cpufreq_driver->target) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 struct cpufreq_governor *t;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700318
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800319 mutex_lock(&cpufreq_governor_mutex);
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700320
321 t = __find_governor(str_governor);
322
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700323 if (t == NULL) {
Kees Cook1a8e1462011-05-04 08:38:56 -0700324 int ret;
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700325
Kees Cook1a8e1462011-05-04 08:38:56 -0700326 mutex_unlock(&cpufreq_governor_mutex);
327 ret = request_module("cpufreq_%s", str_governor);
328 mutex_lock(&cpufreq_governor_mutex);
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700329
Kees Cook1a8e1462011-05-04 08:38:56 -0700330 if (ret == 0)
331 t = __find_governor(str_governor);
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700332 }
333
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700334 if (t != NULL) {
335 *governor = t;
336 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 }
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700338
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800339 mutex_unlock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 }
Dave Jones29464f22009-01-18 01:37:11 -0500341out:
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700342 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
345
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346/**
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530347 * cpufreq_per_cpu_attr_read() / show_##file_name() -
348 * print out cpufreq information
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 *
350 * Write out information from cpufreq_driver->policy[cpu]; object must be
351 * "unsigned int".
352 */
353
Dave Jones32ee8c32006-02-28 00:43:23 -0500354#define show_one(file_name, object) \
355static ssize_t show_##file_name \
Dave Jones905d77c2008-03-05 14:28:32 -0500356(struct cpufreq_policy *policy, char *buf) \
Dave Jones32ee8c32006-02-28 00:43:23 -0500357{ \
Dave Jones29464f22009-01-18 01:37:11 -0500358 return sprintf(buf, "%u\n", policy->object); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359}
360
361show_one(cpuinfo_min_freq, cpuinfo.min_freq);
362show_one(cpuinfo_max_freq, cpuinfo.max_freq);
Thomas Renningered129782009-02-04 01:17:41 +0100363show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364show_one(scaling_min_freq, min);
365show_one(scaling_max_freq, max);
366show_one(scaling_cur_freq, cur);
367
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530368static int __cpufreq_set_policy(struct cpufreq_policy *data,
369 struct cpufreq_policy *policy);
Thomas Renninger7970e082006-04-13 15:14:04 +0200370
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371/**
372 * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
373 */
374#define store_one(file_name, object) \
375static ssize_t store_##file_name \
Dave Jones905d77c2008-03-05 14:28:32 -0500376(struct cpufreq_policy *policy, const char *buf, size_t count) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377{ \
378 unsigned int ret = -EINVAL; \
379 struct cpufreq_policy new_policy; \
380 \
381 ret = cpufreq_get_policy(&new_policy, policy->cpu); \
382 if (ret) \
383 return -EINVAL; \
384 \
Dave Jones29464f22009-01-18 01:37:11 -0500385 ret = sscanf(buf, "%u", &new_policy.object); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 if (ret != 1) \
387 return -EINVAL; \
388 \
Thomas Renninger7970e082006-04-13 15:14:04 +0200389 ret = __cpufreq_set_policy(policy, &new_policy); \
390 policy->user_policy.object = policy->object; \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 \
392 return ret ? ret : count; \
393}
394
Dave Jones29464f22009-01-18 01:37:11 -0500395store_one(scaling_min_freq, min);
396store_one(scaling_max_freq, max);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
398/**
399 * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
400 */
Dave Jones905d77c2008-03-05 14:28:32 -0500401static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
402 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403{
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800404 unsigned int cur_freq = __cpufreq_get(policy->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 if (!cur_freq)
406 return sprintf(buf, "<unknown>");
407 return sprintf(buf, "%u\n", cur_freq);
408}
409
410
411/**
412 * show_scaling_governor - show the current policy for the specified CPU
413 */
Dave Jones905d77c2008-03-05 14:28:32 -0500414static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415{
Dave Jones29464f22009-01-18 01:37:11 -0500416 if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 return sprintf(buf, "powersave\n");
418 else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
419 return sprintf(buf, "performance\n");
420 else if (policy->governor)
Dave Jones29464f22009-01-18 01:37:11 -0500421 return scnprintf(buf, CPUFREQ_NAME_LEN, "%s\n",
422 policy->governor->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 return -EINVAL;
424}
425
426
427/**
428 * store_scaling_governor - store policy for the specified CPU
429 */
Dave Jones905d77c2008-03-05 14:28:32 -0500430static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
431 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432{
433 unsigned int ret = -EINVAL;
434 char str_governor[16];
435 struct cpufreq_policy new_policy;
436
437 ret = cpufreq_get_policy(&new_policy, policy->cpu);
438 if (ret)
439 return ret;
440
Dave Jones29464f22009-01-18 01:37:11 -0500441 ret = sscanf(buf, "%15s", str_governor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 if (ret != 1)
443 return -EINVAL;
444
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530445 if (cpufreq_parse_governor(str_governor, &new_policy.policy,
446 &new_policy.governor))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 return -EINVAL;
448
Thomas Renninger7970e082006-04-13 15:14:04 +0200449 /* Do not use cpufreq_set_policy here or the user_policy.max
450 will be wrongly overridden */
Thomas Renninger7970e082006-04-13 15:14:04 +0200451 ret = __cpufreq_set_policy(policy, &new_policy);
452
453 policy->user_policy.policy = policy->policy;
454 policy->user_policy.governor = policy->governor;
Thomas Renninger7970e082006-04-13 15:14:04 +0200455
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530456 if (ret)
457 return ret;
458 else
459 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460}
461
462/**
463 * show_scaling_driver - show the cpufreq driver currently loaded
464 */
Dave Jones905d77c2008-03-05 14:28:32 -0500465static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466{
467 return scnprintf(buf, CPUFREQ_NAME_LEN, "%s\n", cpufreq_driver->name);
468}
469
470/**
471 * show_scaling_available_governors - show the available CPUfreq governors
472 */
Dave Jones905d77c2008-03-05 14:28:32 -0500473static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
474 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475{
476 ssize_t i = 0;
477 struct cpufreq_governor *t;
478
479 if (!cpufreq_driver->target) {
480 i += sprintf(buf, "performance powersave");
481 goto out;
482 }
483
484 list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
Dave Jones29464f22009-01-18 01:37:11 -0500485 if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
486 - (CPUFREQ_NAME_LEN + 2)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 goto out;
488 i += scnprintf(&buf[i], CPUFREQ_NAME_LEN, "%s ", t->name);
489 }
Dave Jones7d5e3502006-02-02 17:03:42 -0500490out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 i += sprintf(&buf[i], "\n");
492 return i;
493}
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700494
Rusty Russell835481d2009-01-04 05:18:06 -0800495static ssize_t show_cpus(const struct cpumask *mask, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
497 ssize_t i = 0;
498 unsigned int cpu;
499
Rusty Russell835481d2009-01-04 05:18:06 -0800500 for_each_cpu(cpu, mask) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 if (i)
502 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
503 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
504 if (i >= (PAGE_SIZE - 5))
Dave Jones29464f22009-01-18 01:37:11 -0500505 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 }
507 i += sprintf(&buf[i], "\n");
508 return i;
509}
510
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700511/**
512 * show_related_cpus - show the CPUs affected by each transition even if
513 * hw coordination is in use
514 */
515static ssize_t show_related_cpus(struct cpufreq_policy *policy, char *buf)
516{
Rusty Russell835481d2009-01-04 05:18:06 -0800517 if (cpumask_empty(policy->related_cpus))
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700518 return show_cpus(policy->cpus, buf);
519 return show_cpus(policy->related_cpus, buf);
520}
521
522/**
523 * show_affected_cpus - show the CPUs affected by each transition
524 */
525static ssize_t show_affected_cpus(struct cpufreq_policy *policy, char *buf)
526{
527 return show_cpus(policy->cpus, buf);
528}
529
Venki Pallipadi9e769882007-10-26 10:18:21 -0700530static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
Dave Jones905d77c2008-03-05 14:28:32 -0500531 const char *buf, size_t count)
Venki Pallipadi9e769882007-10-26 10:18:21 -0700532{
533 unsigned int freq = 0;
534 unsigned int ret;
535
CHIKAMA masaki879000f2008-06-05 22:46:33 -0700536 if (!policy->governor || !policy->governor->store_setspeed)
Venki Pallipadi9e769882007-10-26 10:18:21 -0700537 return -EINVAL;
538
539 ret = sscanf(buf, "%u", &freq);
540 if (ret != 1)
541 return -EINVAL;
542
543 policy->governor->store_setspeed(policy, freq);
544
545 return count;
546}
547
548static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
549{
CHIKAMA masaki879000f2008-06-05 22:46:33 -0700550 if (!policy->governor || !policy->governor->show_setspeed)
Venki Pallipadi9e769882007-10-26 10:18:21 -0700551 return sprintf(buf, "<unsupported>\n");
552
553 return policy->governor->show_setspeed(policy, buf);
554}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
Thomas Renningere2f74f32009-11-19 12:31:01 +0100556/**
557 * show_scaling_driver - show the current cpufreq HW/BIOS limitation
558 */
559static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
560{
561 unsigned int limit;
562 int ret;
563 if (cpufreq_driver->bios_limit) {
564 ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
565 if (!ret)
566 return sprintf(buf, "%u\n", limit);
567 }
568 return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
569}
570
Borislav Petkov6dad2a22010-03-31 21:56:46 +0200571cpufreq_freq_attr_ro_perm(cpuinfo_cur_freq, 0400);
572cpufreq_freq_attr_ro(cpuinfo_min_freq);
573cpufreq_freq_attr_ro(cpuinfo_max_freq);
574cpufreq_freq_attr_ro(cpuinfo_transition_latency);
575cpufreq_freq_attr_ro(scaling_available_governors);
576cpufreq_freq_attr_ro(scaling_driver);
577cpufreq_freq_attr_ro(scaling_cur_freq);
578cpufreq_freq_attr_ro(bios_limit);
579cpufreq_freq_attr_ro(related_cpus);
580cpufreq_freq_attr_ro(affected_cpus);
581cpufreq_freq_attr_rw(scaling_min_freq);
582cpufreq_freq_attr_rw(scaling_max_freq);
583cpufreq_freq_attr_rw(scaling_governor);
584cpufreq_freq_attr_rw(scaling_setspeed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585
Dave Jones905d77c2008-03-05 14:28:32 -0500586static struct attribute *default_attrs[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 &cpuinfo_min_freq.attr,
588 &cpuinfo_max_freq.attr,
Thomas Renningered129782009-02-04 01:17:41 +0100589 &cpuinfo_transition_latency.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 &scaling_min_freq.attr,
591 &scaling_max_freq.attr,
592 &affected_cpus.attr,
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700593 &related_cpus.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 &scaling_governor.attr,
595 &scaling_driver.attr,
596 &scaling_available_governors.attr,
Venki Pallipadi9e769882007-10-26 10:18:21 -0700597 &scaling_setspeed.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 NULL
599};
600
Thomas Renninger8aa84ad2009-07-24 15:25:05 +0200601struct kobject *cpufreq_global_kobject;
602EXPORT_SYMBOL(cpufreq_global_kobject);
603
Dave Jones29464f22009-01-18 01:37:11 -0500604#define to_policy(k) container_of(k, struct cpufreq_policy, kobj)
605#define to_attr(a) container_of(a, struct freq_attr, attr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
Dave Jones29464f22009-01-18 01:37:11 -0500607static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608{
Dave Jones905d77c2008-03-05 14:28:32 -0500609 struct cpufreq_policy *policy = to_policy(kobj);
610 struct freq_attr *fattr = to_attr(attr);
Dave Jones0db4a8a2008-03-05 14:20:57 -0500611 ssize_t ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 policy = cpufreq_cpu_get(policy->cpu);
613 if (!policy)
Dave Jones0db4a8a2008-03-05 14:20:57 -0500614 goto no_policy;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800615
616 if (lock_policy_rwsem_read(policy->cpu) < 0)
Dave Jones0db4a8a2008-03-05 14:20:57 -0500617 goto fail;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800618
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530619 if (fattr->show)
620 ret = fattr->show(policy, buf);
621 else
622 ret = -EIO;
623
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800624 unlock_policy_rwsem_read(policy->cpu);
Dave Jones0db4a8a2008-03-05 14:20:57 -0500625fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 cpufreq_cpu_put(policy);
Dave Jones0db4a8a2008-03-05 14:20:57 -0500627no_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 return ret;
629}
630
Dave Jones905d77c2008-03-05 14:28:32 -0500631static ssize_t store(struct kobject *kobj, struct attribute *attr,
632 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633{
Dave Jones905d77c2008-03-05 14:28:32 -0500634 struct cpufreq_policy *policy = to_policy(kobj);
635 struct freq_attr *fattr = to_attr(attr);
Dave Jonesa07530b2008-03-05 14:22:25 -0500636 ssize_t ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 policy = cpufreq_cpu_get(policy->cpu);
638 if (!policy)
Dave Jonesa07530b2008-03-05 14:22:25 -0500639 goto no_policy;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800640
641 if (lock_policy_rwsem_write(policy->cpu) < 0)
Dave Jonesa07530b2008-03-05 14:22:25 -0500642 goto fail;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800643
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530644 if (fattr->store)
645 ret = fattr->store(policy, buf, count);
646 else
647 ret = -EIO;
648
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800649 unlock_policy_rwsem_write(policy->cpu);
Dave Jonesa07530b2008-03-05 14:22:25 -0500650fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 cpufreq_cpu_put(policy);
Dave Jonesa07530b2008-03-05 14:22:25 -0500652no_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 return ret;
654}
655
Dave Jones905d77c2008-03-05 14:28:32 -0500656static void cpufreq_sysfs_release(struct kobject *kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657{
Dave Jones905d77c2008-03-05 14:28:32 -0500658 struct cpufreq_policy *policy = to_policy(kobj);
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200659 pr_debug("last reference is dropped\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 complete(&policy->kobj_unregister);
661}
662
Emese Revfy52cf25d2010-01-19 02:58:23 +0100663static const struct sysfs_ops sysfs_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 .show = show,
665 .store = store,
666};
667
668static struct kobj_type ktype_cpufreq = {
669 .sysfs_ops = &sysfs_ops,
670 .default_attrs = default_attrs,
671 .release = cpufreq_sysfs_release,
672};
673
Thomas Renninger4bfa0422009-07-24 15:25:03 +0200674/*
675 * Returns:
676 * Negative: Failure
677 * 0: Success
678 * Positive: When we have a managed CPU and the sysfs got symlinked
679 */
Alex Chiangcf3289d2009-11-17 20:27:08 -0700680static int cpufreq_add_dev_policy(unsigned int cpu,
681 struct cpufreq_policy *policy,
682 struct sys_device *sys_dev)
Dave Jonesecf7e462009-07-08 18:48:47 -0400683{
684 int ret = 0;
685#ifdef CONFIG_SMP
686 unsigned long flags;
687 unsigned int j;
Dave Jonesecf7e462009-07-08 18:48:47 -0400688#ifdef CONFIG_HOTPLUG_CPU
Dmitry Monakhove77b89f2009-10-05 00:38:55 +0400689 struct cpufreq_governor *gov;
690
691 gov = __find_governor(per_cpu(cpufreq_cpu_governor, cpu));
692 if (gov) {
693 policy->governor = gov;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200694 pr_debug("Restoring governor %s for cpu %d\n",
Dave Jonesecf7e462009-07-08 18:48:47 -0400695 policy->governor->name, cpu);
696 }
697#endif
698
699 for_each_cpu(j, policy->cpus) {
700 struct cpufreq_policy *managed_policy;
701
702 if (cpu == j)
703 continue;
704
705 /* Check for existing affected CPUs.
706 * They may not be aware of it due to CPU Hotplug.
707 * cpufreq_cpu_put is called when the device is removed
708 * in __cpufreq_remove_dev()
709 */
710 managed_policy = cpufreq_cpu_get(j);
711 if (unlikely(managed_policy)) {
712
713 /* Set proper policy_cpu */
714 unlock_policy_rwsem_write(cpu);
Tejun Heof1625062009-10-29 22:34:13 +0900715 per_cpu(cpufreq_policy_cpu, cpu) = managed_policy->cpu;
Dave Jonesecf7e462009-07-08 18:48:47 -0400716
717 if (lock_policy_rwsem_write(cpu) < 0) {
718 /* Should not go through policy unlock path */
719 if (cpufreq_driver->exit)
720 cpufreq_driver->exit(policy);
721 cpufreq_cpu_put(managed_policy);
722 return -EBUSY;
723 }
724
725 spin_lock_irqsave(&cpufreq_driver_lock, flags);
726 cpumask_copy(managed_policy->cpus, policy->cpus);
727 per_cpu(cpufreq_cpu_data, cpu) = managed_policy;
728 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
729
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200730 pr_debug("CPU already managed, adding link\n");
Dave Jonesecf7e462009-07-08 18:48:47 -0400731 ret = sysfs_create_link(&sys_dev->kobj,
732 &managed_policy->kobj,
733 "cpufreq");
734 if (ret)
735 cpufreq_cpu_put(managed_policy);
736 /*
737 * Success. We only needed to be added to the mask.
738 * Call driver->exit() because only the cpu parent of
739 * the kobj needed to call init().
740 */
741 if (cpufreq_driver->exit)
742 cpufreq_driver->exit(policy);
Thomas Renninger4bfa0422009-07-24 15:25:03 +0200743
744 if (!ret)
745 return 1;
746 else
747 return ret;
Dave Jonesecf7e462009-07-08 18:48:47 -0400748 }
749 }
750#endif
751 return ret;
752}
753
754
Dave Jones19d6f7e2009-07-08 17:35:39 -0400755/* symlink affected CPUs */
Alex Chiangcf3289d2009-11-17 20:27:08 -0700756static int cpufreq_add_dev_symlink(unsigned int cpu,
757 struct cpufreq_policy *policy)
Dave Jones19d6f7e2009-07-08 17:35:39 -0400758{
759 unsigned int j;
760 int ret = 0;
761
762 for_each_cpu(j, policy->cpus) {
763 struct cpufreq_policy *managed_policy;
764 struct sys_device *cpu_sys_dev;
765
766 if (j == cpu)
767 continue;
768 if (!cpu_online(j))
769 continue;
770
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200771 pr_debug("CPU %u already managed, adding link\n", j);
Dave Jones19d6f7e2009-07-08 17:35:39 -0400772 managed_policy = cpufreq_cpu_get(cpu);
773 cpu_sys_dev = get_cpu_sysdev(j);
774 ret = sysfs_create_link(&cpu_sys_dev->kobj, &policy->kobj,
775 "cpufreq");
776 if (ret) {
777 cpufreq_cpu_put(managed_policy);
778 return ret;
779 }
780 }
781 return ret;
782}
783
Alex Chiangcf3289d2009-11-17 20:27:08 -0700784static int cpufreq_add_dev_interface(unsigned int cpu,
785 struct cpufreq_policy *policy,
786 struct sys_device *sys_dev)
Dave Jones909a6942009-07-08 18:05:42 -0400787{
Dave Jonesecf7e462009-07-08 18:48:47 -0400788 struct cpufreq_policy new_policy;
Dave Jones909a6942009-07-08 18:05:42 -0400789 struct freq_attr **drv_attr;
790 unsigned long flags;
791 int ret = 0;
792 unsigned int j;
793
794 /* prepare interface data */
795 ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
796 &sys_dev->kobj, "cpufreq");
797 if (ret)
798 return ret;
799
800 /* set up files for this cpu device */
801 drv_attr = cpufreq_driver->attr;
802 while ((drv_attr) && (*drv_attr)) {
803 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
804 if (ret)
805 goto err_out_kobj_put;
806 drv_attr++;
807 }
808 if (cpufreq_driver->get) {
809 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
810 if (ret)
811 goto err_out_kobj_put;
812 }
813 if (cpufreq_driver->target) {
814 ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
815 if (ret)
816 goto err_out_kobj_put;
817 }
Thomas Renningere2f74f32009-11-19 12:31:01 +0100818 if (cpufreq_driver->bios_limit) {
819 ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
820 if (ret)
821 goto err_out_kobj_put;
822 }
Dave Jones909a6942009-07-08 18:05:42 -0400823
824 spin_lock_irqsave(&cpufreq_driver_lock, flags);
825 for_each_cpu(j, policy->cpus) {
Julia Lawallbec037a2010-08-05 22:23:00 +0200826 if (!cpu_online(j))
827 continue;
Dave Jones909a6942009-07-08 18:05:42 -0400828 per_cpu(cpufreq_cpu_data, j) = policy;
Tejun Heof1625062009-10-29 22:34:13 +0900829 per_cpu(cpufreq_policy_cpu, j) = policy->cpu;
Dave Jones909a6942009-07-08 18:05:42 -0400830 }
831 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
832
833 ret = cpufreq_add_dev_symlink(cpu, policy);
Dave Jonesecf7e462009-07-08 18:48:47 -0400834 if (ret)
835 goto err_out_kobj_put;
836
837 memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));
838 /* assure that the starting sequence is run in __cpufreq_set_policy */
839 policy->governor = NULL;
840
841 /* set default policy */
842 ret = __cpufreq_set_policy(policy, &new_policy);
843 policy->user_policy.policy = policy->policy;
844 policy->user_policy.governor = policy->governor;
845
846 if (ret) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200847 pr_debug("setting policy failed\n");
Dave Jonesecf7e462009-07-08 18:48:47 -0400848 if (cpufreq_driver->exit)
849 cpufreq_driver->exit(policy);
850 }
Dave Jones909a6942009-07-08 18:05:42 -0400851 return ret;
852
853err_out_kobj_put:
854 kobject_put(&policy->kobj);
855 wait_for_completion(&policy->kobj_unregister);
856 return ret;
857}
858
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
860/**
861 * cpufreq_add_dev - add a CPU device
862 *
Dave Jones32ee8c32006-02-28 00:43:23 -0500863 * Adds the cpufreq interface for a CPU device.
Mathieu Desnoyers3f4a7822009-07-03 11:25:16 -0400864 *
865 * The Oracle says: try running cpufreq registration/unregistration concurrently
866 * with with cpu hotplugging and all hell will break loose. Tried to clean this
867 * mess up, but more thorough testing is needed. - Mathieu
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 */
Dave Jones905d77c2008-03-05 14:28:32 -0500869static int cpufreq_add_dev(struct sys_device *sys_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870{
871 unsigned int cpu = sys_dev->id;
Prarit Bhargava90e41ba2009-11-12 09:18:46 -0500872 int ret = 0, found = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 struct cpufreq_policy *policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 unsigned long flags;
875 unsigned int j;
Prarit Bhargava90e41ba2009-11-12 09:18:46 -0500876#ifdef CONFIG_HOTPLUG_CPU
877 int sibling;
878#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879
Ashok Rajc32b6b82005-10-30 14:59:54 -0800880 if (cpu_is_offline(cpu))
881 return 0;
882
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200883 pr_debug("adding CPU %u\n", cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884
885#ifdef CONFIG_SMP
886 /* check whether a different CPU already registered this
887 * CPU because it is in the same boat. */
888 policy = cpufreq_cpu_get(cpu);
889 if (unlikely(policy)) {
Dave Jones8ff69732006-03-05 03:37:23 -0500890 cpufreq_cpu_put(policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 return 0;
892 }
893#endif
894
895 if (!try_module_get(cpufreq_driver->owner)) {
896 ret = -EINVAL;
897 goto module_out;
898 }
899
Dave Jones059019a2009-07-08 16:30:03 -0400900 ret = -ENOMEM;
Dave Jonese98df502005-10-20 15:17:43 -0700901 policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
Dave Jones059019a2009-07-08 16:30:03 -0400902 if (!policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 goto nomem_out;
Dave Jones059019a2009-07-08 16:30:03 -0400904
905 if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
Mathieu Desnoyers3f4a7822009-07-03 11:25:16 -0400906 goto err_free_policy;
Dave Jones059019a2009-07-08 16:30:03 -0400907
908 if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
Mathieu Desnoyers3f4a7822009-07-03 11:25:16 -0400909 goto err_free_cpumask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910
911 policy->cpu = cpu;
Rusty Russell835481d2009-01-04 05:18:06 -0800912 cpumask_copy(policy->cpus, cpumask_of(cpu));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800914 /* Initially set CPU itself as the policy_cpu */
Tejun Heof1625062009-10-29 22:34:13 +0900915 per_cpu(cpufreq_policy_cpu, cpu) = cpu;
Mathieu Desnoyers3f4a7822009-07-03 11:25:16 -0400916 ret = (lock_policy_rwsem_write(cpu) < 0);
917 WARN_ON(ret);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800918
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 init_completion(&policy->kobj_unregister);
David Howells65f27f32006-11-22 14:55:48 +0000920 INIT_WORK(&policy->update, handle_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921
Thomas Renninger8122c6c2007-10-02 13:28:09 -0700922 /* Set governor before ->init, so that driver could check it */
Prarit Bhargava90e41ba2009-11-12 09:18:46 -0500923#ifdef CONFIG_HOTPLUG_CPU
924 for_each_online_cpu(sibling) {
925 struct cpufreq_policy *cp = per_cpu(cpufreq_cpu_data, sibling);
926 if (cp && cp->governor &&
927 (cpumask_test_cpu(cpu, cp->related_cpus))) {
928 policy->governor = cp->governor;
929 found = 1;
930 break;
931 }
932 }
933#endif
934 if (!found)
935 policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 /* call driver. From then on the cpufreq must be able
937 * to accept all calls to ->verify and ->setpolicy for this CPU
938 */
939 ret = cpufreq_driver->init(policy);
940 if (ret) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200941 pr_debug("initialization failed\n");
Mathieu Desnoyers3f4a7822009-07-03 11:25:16 -0400942 goto err_unlock_policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 }
Mike Chan187d9f42008-12-04 12:19:17 -0800944 policy->user_policy.min = policy->min;
945 policy->user_policy.max = policy->max;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946
Thomas Renningera1531ac2008-07-29 22:32:58 -0700947 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
948 CPUFREQ_START, policy);
949
Dave Jonesecf7e462009-07-08 18:48:47 -0400950 ret = cpufreq_add_dev_policy(cpu, policy, sys_dev);
Thomas Renninger4bfa0422009-07-24 15:25:03 +0200951 if (ret) {
952 if (ret > 0)
953 /* This is a managed cpu, symlink created,
954 exit with 0 */
955 ret = 0;
Dave Jonesecf7e462009-07-08 18:48:47 -0400956 goto err_unlock_policy;
Thomas Renninger4bfa0422009-07-24 15:25:03 +0200957 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958
Dave Jones909a6942009-07-08 18:05:42 -0400959 ret = cpufreq_add_dev_interface(cpu, policy, sys_dev);
Dave Jones19d6f7e2009-07-08 17:35:39 -0400960 if (ret)
961 goto err_out_unregister;
Dave Jones8ff69732006-03-05 03:37:23 -0500962
Lothar Waßmanndca02612008-05-29 17:54:52 +0200963 unlock_policy_rwsem_write(cpu);
964
Greg Kroah-Hartman038c5b32007-12-17 15:54:39 -0400965 kobject_uevent(&policy->kobj, KOBJ_ADD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 module_put(cpufreq_driver->owner);
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200967 pr_debug("initialization complete\n");
Dave Jones87c32272006-03-29 01:48:37 -0500968
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 return 0;
970
971
972err_out_unregister:
973 spin_lock_irqsave(&cpufreq_driver_lock, flags);
Rusty Russell835481d2009-01-04 05:18:06 -0800974 for_each_cpu(j, policy->cpus)
Mike Travis7a6aedf2008-03-25 15:06:53 -0700975 per_cpu(cpufreq_cpu_data, j) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
977
Greg Kroah-Hartmanc10997f2007-12-20 08:13:05 -0800978 kobject_put(&policy->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 wait_for_completion(&policy->kobj_unregister);
980
Mathieu Desnoyers3f4a7822009-07-03 11:25:16 -0400981err_unlock_policy:
Dave Jones45709112008-03-05 14:07:34 -0500982 unlock_policy_rwsem_write(cpu);
Xiaotian Fengcad70a62010-07-20 20:11:02 +0800983 free_cpumask_var(policy->related_cpus);
Mathieu Desnoyers3f4a7822009-07-03 11:25:16 -0400984err_free_cpumask:
985 free_cpumask_var(policy->cpus);
986err_free_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 kfree(policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988nomem_out:
989 module_put(cpufreq_driver->owner);
Ashok Rajc32b6b82005-10-30 14:59:54 -0800990module_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 return ret;
992}
993
994
995/**
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800996 * __cpufreq_remove_dev - remove a CPU device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 *
998 * Removes the cpufreq interface for a CPU device.
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800999 * Caller should already have policy_rwsem in write mode for this CPU.
1000 * This routine frees the rwsem before returning.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 */
Dave Jones905d77c2008-03-05 14:28:32 -05001002static int __cpufreq_remove_dev(struct sys_device *sys_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003{
1004 unsigned int cpu = sys_dev->id;
1005 unsigned long flags;
1006 struct cpufreq_policy *data;
Amerigo Wang499bca92010-03-04 03:23:46 -05001007 struct kobject *kobj;
1008 struct completion *cmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009#ifdef CONFIG_SMP
Grant Coadye738cf62005-11-21 21:32:28 -08001010 struct sys_device *cpu_sys_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 unsigned int j;
1012#endif
1013
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001014 pr_debug("unregistering CPU %u\n", cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015
1016 spin_lock_irqsave(&cpufreq_driver_lock, flags);
Mike Travis7a6aedf2008-03-25 15:06:53 -07001017 data = per_cpu(cpufreq_cpu_data, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018
1019 if (!data) {
1020 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001021 unlock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 return -EINVAL;
1023 }
Mike Travis7a6aedf2008-03-25 15:06:53 -07001024 per_cpu(cpufreq_cpu_data, cpu) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025
1026
1027#ifdef CONFIG_SMP
1028 /* if this isn't the CPU which is the parent of the kobj, we
Dave Jones32ee8c32006-02-28 00:43:23 -05001029 * only need to unlink, put and exit
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 */
1031 if (unlikely(cpu != data->cpu)) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001032 pr_debug("removing link\n");
Rusty Russell835481d2009-01-04 05:18:06 -08001033 cpumask_clear_cpu(cpu, data->cpus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Amerigo Wang499bca92010-03-04 03:23:46 -05001035 kobj = &sys_dev->kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 cpufreq_cpu_put(data);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001037 unlock_policy_rwsem_write(cpu);
Amerigo Wang499bca92010-03-04 03:23:46 -05001038 sysfs_remove_link(kobj, "cpufreq");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 return 0;
1040 }
1041#endif
1042
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043#ifdef CONFIG_SMP
Thomas Renninger084f3492007-07-09 11:35:28 -07001044
1045#ifdef CONFIG_HOTPLUG_CPU
Dmitry Monakhove77b89f2009-10-05 00:38:55 +04001046 strncpy(per_cpu(cpufreq_cpu_governor, cpu), data->governor->name,
1047 CPUFREQ_NAME_LEN);
Thomas Renninger084f3492007-07-09 11:35:28 -07001048#endif
1049
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 /* if we have other CPUs still registered, we need to unlink them,
1051 * or else wait_for_completion below will lock up. Clean the
Mike Travis7a6aedf2008-03-25 15:06:53 -07001052 * per_cpu(cpufreq_cpu_data) while holding the lock, and remove
1053 * the sysfs links afterwards.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 */
Rusty Russell835481d2009-01-04 05:18:06 -08001055 if (unlikely(cpumask_weight(data->cpus) > 1)) {
1056 for_each_cpu(j, data->cpus) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 if (j == cpu)
1058 continue;
Mike Travis7a6aedf2008-03-25 15:06:53 -07001059 per_cpu(cpufreq_cpu_data, j) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 }
1061 }
1062
1063 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1064
Rusty Russell835481d2009-01-04 05:18:06 -08001065 if (unlikely(cpumask_weight(data->cpus) > 1)) {
1066 for_each_cpu(j, data->cpus) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 if (j == cpu)
1068 continue;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001069 pr_debug("removing link for cpu %u\n", j);
Thomas Renninger084f3492007-07-09 11:35:28 -07001070#ifdef CONFIG_HOTPLUG_CPU
Dmitry Monakhove77b89f2009-10-05 00:38:55 +04001071 strncpy(per_cpu(cpufreq_cpu_governor, j),
1072 data->governor->name, CPUFREQ_NAME_LEN);
Thomas Renninger084f3492007-07-09 11:35:28 -07001073#endif
Ashok Rajd434fca2005-10-30 14:59:52 -08001074 cpu_sys_dev = get_cpu_sysdev(j);
Amerigo Wang499bca92010-03-04 03:23:46 -05001075 kobj = &cpu_sys_dev->kobj;
1076 unlock_policy_rwsem_write(cpu);
1077 sysfs_remove_link(kobj, "cpufreq");
1078 lock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 cpufreq_cpu_put(data);
1080 }
1081 }
1082#else
1083 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1084#endif
1085
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 if (cpufreq_driver->target)
1087 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001088
Amerigo Wang499bca92010-03-04 03:23:46 -05001089 kobj = &data->kobj;
1090 cmp = &data->kobj_unregister;
1091 unlock_policy_rwsem_write(cpu);
1092 kobject_put(kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093
1094 /* we need to make sure that the underlying kobj is actually
Dave Jones32ee8c32006-02-28 00:43:23 -05001095 * not referenced anymore by anybody before we proceed with
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 * unloading.
1097 */
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001098 pr_debug("waiting for dropping of refcount\n");
Amerigo Wang499bca92010-03-04 03:23:46 -05001099 wait_for_completion(cmp);
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001100 pr_debug("wait complete\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101
Amerigo Wang499bca92010-03-04 03:23:46 -05001102 lock_policy_rwsem_write(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 if (cpufreq_driver->exit)
1104 cpufreq_driver->exit(data);
venkatesh.pallipadi@intel.com7d26e2d2009-07-02 17:08:30 -07001105 unlock_policy_rwsem_write(cpu);
1106
Jacob Shin27ecddc2011-04-27 13:32:11 -05001107#ifdef CONFIG_HOTPLUG_CPU
1108 /* when the CPU which is the parent of the kobj is hotplugged
1109 * offline, check for siblings, and create cpufreq sysfs interface
1110 * and symlinks
1111 */
1112 if (unlikely(cpumask_weight(data->cpus) > 1)) {
1113 /* first sibling now owns the new sysfs dir */
1114 cpumask_clear_cpu(cpu, data->cpus);
1115 cpufreq_add_dev(get_cpu_sysdev(cpumask_first(data->cpus)));
1116
1117 /* finally remove our own symlink */
1118 lock_policy_rwsem_write(cpu);
1119 __cpufreq_remove_dev(sys_dev);
1120 }
1121#endif
1122
Rusty Russell835481d2009-01-04 05:18:06 -08001123 free_cpumask_var(data->related_cpus);
1124 free_cpumask_var(data->cpus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 kfree(data);
1126
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 return 0;
1128}
1129
1130
Dave Jones905d77c2008-03-05 14:28:32 -05001131static int cpufreq_remove_dev(struct sys_device *sys_dev)
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001132{
1133 unsigned int cpu = sys_dev->id;
1134 int retval;
Venki Pallipadiec282972007-03-26 12:03:19 -07001135
1136 if (cpu_is_offline(cpu))
1137 return 0;
1138
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001139 if (unlikely(lock_policy_rwsem_write(cpu)))
1140 BUG();
1141
1142 retval = __cpufreq_remove_dev(sys_dev);
1143 return retval;
1144}
1145
1146
David Howells65f27f32006-11-22 14:55:48 +00001147static void handle_update(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148{
David Howells65f27f32006-11-22 14:55:48 +00001149 struct cpufreq_policy *policy =
1150 container_of(work, struct cpufreq_policy, update);
1151 unsigned int cpu = policy->cpu;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001152 pr_debug("handle_update for cpu %u called\n", cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 cpufreq_update_policy(cpu);
1154}
1155
1156/**
1157 * cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're in deep trouble.
1158 * @cpu: cpu number
1159 * @old_freq: CPU frequency the kernel thinks the CPU runs at
1160 * @new_freq: CPU frequency the CPU actually runs at
1161 *
Dave Jones29464f22009-01-18 01:37:11 -05001162 * We adjust to current frequency first, and need to clean up later.
1163 * So either call to cpufreq_update_policy() or schedule handle_update()).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 */
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301165static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
1166 unsigned int new_freq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167{
1168 struct cpufreq_freqs freqs;
1169
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001170 pr_debug("Warning: CPU frequency out of sync: cpufreq and timing "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
1172
1173 freqs.cpu = cpu;
1174 freqs.old = old_freq;
1175 freqs.new = new_freq;
1176 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
1177 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
1178}
1179
1180
Dave Jones32ee8c32006-02-28 00:43:23 -05001181/**
Dhaval Giani4ab70df2006-12-13 14:49:15 +05301182 * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001183 * @cpu: CPU number
1184 *
1185 * This is the last known freq, without actually getting it from the driver.
1186 * Return value will be same as what is shown in scaling_cur_freq in sysfs.
1187 */
1188unsigned int cpufreq_quick_get(unsigned int cpu)
1189{
1190 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301191 unsigned int ret_freq = 0;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001192
1193 if (policy) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301194 ret_freq = policy->cur;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001195 cpufreq_cpu_put(policy);
1196 }
1197
Dave Jones4d34a672008-02-07 16:33:49 -05001198 return ret_freq;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001199}
1200EXPORT_SYMBOL(cpufreq_quick_get);
1201
Jesse Barnes3d737102011-06-28 10:59:12 -07001202/**
1203 * cpufreq_quick_get_max - get the max reported CPU frequency for this CPU
1204 * @cpu: CPU number
1205 *
1206 * Just return the max possible frequency for a given CPU.
1207 */
1208unsigned int cpufreq_quick_get_max(unsigned int cpu)
1209{
1210 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1211 unsigned int ret_freq = 0;
1212
1213 if (policy) {
1214 ret_freq = policy->max;
1215 cpufreq_cpu_put(policy);
1216 }
1217
1218 return ret_freq;
1219}
1220EXPORT_SYMBOL(cpufreq_quick_get_max);
1221
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001222
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001223static unsigned int __cpufreq_get(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224{
Mike Travis7a6aedf2008-03-25 15:06:53 -07001225 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301226 unsigned int ret_freq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 if (!cpufreq_driver->get)
Dave Jones4d34a672008-02-07 16:33:49 -05001229 return ret_freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301231 ret_freq = cpufreq_driver->get(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301233 if (ret_freq && policy->cur &&
1234 !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1235 /* verify no discrepancy between actual and
1236 saved value exists */
1237 if (unlikely(ret_freq != policy->cur)) {
1238 cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 schedule_work(&policy->update);
1240 }
1241 }
1242
Dave Jones4d34a672008-02-07 16:33:49 -05001243 return ret_freq;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001244}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001246/**
1247 * cpufreq_get - get the current CPU frequency (in kHz)
1248 * @cpu: CPU number
1249 *
1250 * Get the CPU current (static) CPU frequency
1251 */
1252unsigned int cpufreq_get(unsigned int cpu)
1253{
1254 unsigned int ret_freq = 0;
1255 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1256
1257 if (!policy)
1258 goto out;
1259
1260 if (unlikely(lock_policy_rwsem_read(cpu)))
1261 goto out_policy;
1262
1263 ret_freq = __cpufreq_get(cpu);
1264
1265 unlock_policy_rwsem_read(cpu);
1266
1267out_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 cpufreq_cpu_put(policy);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001269out:
Dave Jones4d34a672008-02-07 16:33:49 -05001270 return ret_freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271}
1272EXPORT_SYMBOL(cpufreq_get);
1273
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001274static struct sysdev_driver cpufreq_sysdev_driver = {
1275 .add = cpufreq_add_dev,
1276 .remove = cpufreq_remove_dev,
1277};
1278
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279
1280/**
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001281 * cpufreq_bp_suspend - Prepare the boot CPU for system suspend.
1282 *
1283 * This function is only executed for the boot processor. The other CPUs
1284 * have been put offline by means of CPU hotplug.
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001285 */
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001286static int cpufreq_bp_suspend(void)
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001287{
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301288 int ret = 0;
Dave Jones4bc5d342009-08-04 14:03:25 -04001289
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001290 int cpu = smp_processor_id();
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001291 struct cpufreq_policy *cpu_policy;
1292
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001293 pr_debug("suspending cpu %u\n", cpu);
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001294
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001295 /* If there's no policy for the boot CPU, we have nothing to do. */
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001296 cpu_policy = cpufreq_cpu_get(cpu);
1297 if (!cpu_policy)
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001298 return 0;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001299
1300 if (cpufreq_driver->suspend) {
Rafael J. Wysocki7ca64e22011-03-10 21:13:05 +01001301 ret = cpufreq_driver->suspend(cpu_policy);
Dominik Brodowskice6c3992009-08-07 22:58:51 +02001302 if (ret)
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001303 printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
1304 "step on CPU %u\n", cpu_policy->cpu);
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001305 }
1306
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001307 cpufreq_cpu_put(cpu_policy);
Dave Jonesc9060492008-02-07 16:32:18 -05001308 return ret;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001309}
1310
1311/**
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001312 * cpufreq_bp_resume - Restore proper frequency handling of the boot CPU.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 *
1314 * 1.) resume CPUfreq hardware support (cpufreq_driver->resume())
Dominik Brodowskice6c3992009-08-07 22:58:51 +02001315 * 2.) schedule call cpufreq_update_policy() ASAP as interrupts are
1316 * restored. It will verify that the current freq is in sync with
1317 * what we believe it to be. This is a bit later than when it
1318 * should be, but nonethteless it's better than calling
1319 * cpufreq_driver->get() here which might re-enable interrupts...
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001320 *
1321 * This function is only executed for the boot CPU. The other CPUs have not
1322 * been turned on yet.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 */
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001324static void cpufreq_bp_resume(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325{
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301326 int ret = 0;
Dave Jones4bc5d342009-08-04 14:03:25 -04001327
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001328 int cpu = smp_processor_id();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 struct cpufreq_policy *cpu_policy;
1330
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001331 pr_debug("resuming cpu %u\n", cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001333 /* If there's no policy for the boot CPU, we have nothing to do. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 cpu_policy = cpufreq_cpu_get(cpu);
1335 if (!cpu_policy)
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001336 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337
1338 if (cpufreq_driver->resume) {
1339 ret = cpufreq_driver->resume(cpu_policy);
1340 if (ret) {
1341 printk(KERN_ERR "cpufreq: resume failed in ->resume "
1342 "step on CPU %u\n", cpu_policy->cpu);
Dave Jonesc9060492008-02-07 16:32:18 -05001343 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 }
1345 }
1346
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 schedule_work(&cpu_policy->update);
Dominik Brodowskice6c3992009-08-07 22:58:51 +02001348
Dave Jonesc9060492008-02-07 16:32:18 -05001349fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 cpufreq_cpu_put(cpu_policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351}
1352
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001353static struct syscore_ops cpufreq_syscore_ops = {
1354 .suspend = cpufreq_bp_suspend,
1355 .resume = cpufreq_bp_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356};
1357
1358
1359/*********************************************************************
1360 * NOTIFIER LISTS INTERFACE *
1361 *********************************************************************/
1362
1363/**
1364 * cpufreq_register_notifier - register a driver with cpufreq
1365 * @nb: notifier function to register
1366 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1367 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001368 * Add a driver to one of two lists: either a list of drivers that
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 * are notified about clock rate changes (once before and once after
1370 * the transition), or a list of drivers that are notified about
1371 * changes in cpufreq policy.
1372 *
1373 * This function may sleep, and has the same return conditions as
Alan Sterne041c682006-03-27 01:16:30 -08001374 * blocking_notifier_chain_register.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 */
1376int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1377{
1378 int ret;
1379
Cesar Eduardo Barros74212ca2008-02-16 08:41:24 -02001380 WARN_ON(!init_cpufreq_transition_notifier_list_called);
1381
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 switch (list) {
1383 case CPUFREQ_TRANSITION_NOTIFIER:
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001384 ret = srcu_notifier_chain_register(
Alan Sterne041c682006-03-27 01:16:30 -08001385 &cpufreq_transition_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 break;
1387 case CPUFREQ_POLICY_NOTIFIER:
Alan Sterne041c682006-03-27 01:16:30 -08001388 ret = blocking_notifier_chain_register(
1389 &cpufreq_policy_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 break;
1391 default:
1392 ret = -EINVAL;
1393 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394
1395 return ret;
1396}
1397EXPORT_SYMBOL(cpufreq_register_notifier);
1398
1399
1400/**
1401 * cpufreq_unregister_notifier - unregister a driver with cpufreq
1402 * @nb: notifier block to be unregistered
1403 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1404 *
1405 * Remove a driver from the CPU frequency notifier list.
1406 *
1407 * This function may sleep, and has the same return conditions as
Alan Sterne041c682006-03-27 01:16:30 -08001408 * blocking_notifier_chain_unregister.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 */
1410int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1411{
1412 int ret;
1413
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 switch (list) {
1415 case CPUFREQ_TRANSITION_NOTIFIER:
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001416 ret = srcu_notifier_chain_unregister(
Alan Sterne041c682006-03-27 01:16:30 -08001417 &cpufreq_transition_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 break;
1419 case CPUFREQ_POLICY_NOTIFIER:
Alan Sterne041c682006-03-27 01:16:30 -08001420 ret = blocking_notifier_chain_unregister(
1421 &cpufreq_policy_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 break;
1423 default:
1424 ret = -EINVAL;
1425 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426
1427 return ret;
1428}
1429EXPORT_SYMBOL(cpufreq_unregister_notifier);
1430
1431
1432/*********************************************************************
1433 * GOVERNORS *
1434 *********************************************************************/
1435
1436
1437int __cpufreq_driver_target(struct cpufreq_policy *policy,
1438 unsigned int target_freq,
1439 unsigned int relation)
1440{
1441 int retval = -EINVAL;
Ashok Rajc32b6b82005-10-30 14:59:54 -08001442
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001443 pr_debug("target for CPU %u: %u kHz, relation %u\n", policy->cpu,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 target_freq, relation);
1445 if (cpu_online(policy->cpu) && cpufreq_driver->target)
1446 retval = cpufreq_driver->target(policy, target_freq, relation);
Ashok Raj90d45d12005-11-08 21:34:24 -08001447
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 return retval;
1449}
1450EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1451
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452int cpufreq_driver_target(struct cpufreq_policy *policy,
1453 unsigned int target_freq,
1454 unsigned int relation)
1455{
Julia Lawallf1829e42008-07-25 22:44:53 +02001456 int ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457
1458 policy = cpufreq_cpu_get(policy->cpu);
1459 if (!policy)
Julia Lawallf1829e42008-07-25 22:44:53 +02001460 goto no_policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001462 if (unlikely(lock_policy_rwsem_write(policy->cpu)))
Julia Lawallf1829e42008-07-25 22:44:53 +02001463 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464
1465 ret = __cpufreq_driver_target(policy, target_freq, relation);
1466
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001467 unlock_policy_rwsem_write(policy->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468
Julia Lawallf1829e42008-07-25 22:44:53 +02001469fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 cpufreq_cpu_put(policy);
Julia Lawallf1829e42008-07-25 22:44:53 +02001471no_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 return ret;
1473}
1474EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1475
venkatesh.pallipadi@intel.combf0b90e2008-08-04 11:59:07 -07001476int __cpufreq_driver_getavg(struct cpufreq_policy *policy, unsigned int cpu)
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001477{
1478 int ret = 0;
1479
1480 policy = cpufreq_cpu_get(policy->cpu);
1481 if (!policy)
1482 return -EINVAL;
1483
venkatesh.pallipadi@intel.combf0b90e2008-08-04 11:59:07 -07001484 if (cpu_online(cpu) && cpufreq_driver->getavg)
1485 ret = cpufreq_driver->getavg(policy, cpu);
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001486
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001487 cpufreq_cpu_put(policy);
1488 return ret;
1489}
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001490EXPORT_SYMBOL_GPL(__cpufreq_driver_getavg);
Venkatesh Pallipadidfde5d62006-10-03 12:38:45 -07001491
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001492/*
Arjan van de Ven153d7f32006-07-26 15:40:07 +02001493 * when "event" is CPUFREQ_GOV_LIMITS
1494 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301496static int __cpufreq_governor(struct cpufreq_policy *policy,
1497 unsigned int event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498{
Dave Jonescc993ca2005-07-28 09:43:56 -07001499 int ret;
Thomas Renninger6afde102007-10-02 13:28:13 -07001500
1501 /* Only must be defined when default governor is known to have latency
1502 restrictions, like e.g. conservative or ondemand.
1503 That this is the case is already ensured in Kconfig
1504 */
1505#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
1506 struct cpufreq_governor *gov = &cpufreq_gov_performance;
1507#else
1508 struct cpufreq_governor *gov = NULL;
1509#endif
Thomas Renninger1c256242007-10-02 13:28:12 -07001510
1511 if (policy->governor->max_transition_latency &&
1512 policy->cpuinfo.transition_latency >
1513 policy->governor->max_transition_latency) {
Thomas Renninger6afde102007-10-02 13:28:13 -07001514 if (!gov)
1515 return -EINVAL;
1516 else {
1517 printk(KERN_WARNING "%s governor failed, too long"
1518 " transition latency of HW, fallback"
1519 " to %s governor\n",
1520 policy->governor->name,
1521 gov->name);
1522 policy->governor = gov;
1523 }
Thomas Renninger1c256242007-10-02 13:28:12 -07001524 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525
1526 if (!try_module_get(policy->governor->owner))
1527 return -EINVAL;
1528
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001529 pr_debug("__cpufreq_governor for CPU %u, event %u\n",
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301530 policy->cpu, event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 ret = policy->governor->governor(policy, event);
1532
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301533 /* we keep one module reference alive for
1534 each CPU governed by this CPU */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 if ((event != CPUFREQ_GOV_START) || ret)
1536 module_put(policy->governor->owner);
1537 if ((event == CPUFREQ_GOV_STOP) && !ret)
1538 module_put(policy->governor->owner);
1539
1540 return ret;
1541}
1542
1543
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544int cpufreq_register_governor(struct cpufreq_governor *governor)
1545{
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07001546 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547
1548 if (!governor)
1549 return -EINVAL;
1550
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08001551 mutex_lock(&cpufreq_governor_mutex);
Dave Jones32ee8c32006-02-28 00:43:23 -05001552
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07001553 err = -EBUSY;
1554 if (__find_governor(governor->name) == NULL) {
1555 err = 0;
1556 list_add(&governor->governor_list, &cpufreq_governor_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558
Dave Jones32ee8c32006-02-28 00:43:23 -05001559 mutex_unlock(&cpufreq_governor_mutex);
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07001560 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561}
1562EXPORT_SYMBOL_GPL(cpufreq_register_governor);
1563
1564
1565void cpufreq_unregister_governor(struct cpufreq_governor *governor)
1566{
Prarit Bhargava90e41ba2009-11-12 09:18:46 -05001567#ifdef CONFIG_HOTPLUG_CPU
1568 int cpu;
1569#endif
1570
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 if (!governor)
1572 return;
1573
Prarit Bhargava90e41ba2009-11-12 09:18:46 -05001574#ifdef CONFIG_HOTPLUG_CPU
1575 for_each_present_cpu(cpu) {
1576 if (cpu_online(cpu))
1577 continue;
1578 if (!strcmp(per_cpu(cpufreq_cpu_governor, cpu), governor->name))
1579 strcpy(per_cpu(cpufreq_cpu_governor, cpu), "\0");
1580 }
1581#endif
1582
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08001583 mutex_lock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 list_del(&governor->governor_list);
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08001585 mutex_unlock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 return;
1587}
1588EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
1589
1590
1591
1592/*********************************************************************
1593 * POLICY INTERFACE *
1594 *********************************************************************/
1595
1596/**
1597 * cpufreq_get_policy - get the current cpufreq_policy
Dave Jones29464f22009-01-18 01:37:11 -05001598 * @policy: struct cpufreq_policy into which the current cpufreq_policy
1599 * is written
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600 *
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
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001630 pr_debug("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 policy->min, policy->max);
1632
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301633 memcpy(&policy->cpuinfo, &data->cpuinfo,
1634 sizeof(struct cpufreq_cpuinfo));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635
Yi Yang53391fa2008-01-30 13:33:34 +01001636 if (policy->min > data->max || policy->max < data->min) {
Mattia Dongili9c9a43e2006-07-05 23:12:20 +02001637 ret = -EINVAL;
1638 goto error_out;
1639 }
1640
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 /* verify the cpu speed can be set within this limit */
1642 ret = cpufreq_driver->verify(policy);
1643 if (ret)
1644 goto error_out;
1645
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 /* adjust if necessary - all reasons */
Alan Sterne041c682006-03-27 01:16:30 -08001647 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1648 CPUFREQ_ADJUST, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649
1650 /* adjust if necessary - hardware incompatibility*/
Alan Sterne041c682006-03-27 01:16:30 -08001651 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1652 CPUFREQ_INCOMPATIBLE, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
1654 /* verify the cpu speed can be set within this limit,
1655 which might be different to the first one */
1656 ret = cpufreq_driver->verify(policy);
Alan Sterne041c682006-03-27 01:16:30 -08001657 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 goto error_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659
1660 /* notification of the new policy */
Alan Sterne041c682006-03-27 01:16:30 -08001661 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1662 CPUFREQ_NOTIFY, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
Dave Jones7d5e3502006-02-02 17:03:42 -05001664 data->min = policy->min;
1665 data->max = policy->max;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001667 pr_debug("new min and max freqs are %u - %u kHz\n",
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301668 data->min, data->max);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669
1670 if (cpufreq_driver->setpolicy) {
1671 data->policy = policy->policy;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001672 pr_debug("setting range\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 ret = cpufreq_driver->setpolicy(policy);
1674 } else {
1675 if (policy->governor != data->governor) {
1676 /* save old, working values */
1677 struct cpufreq_governor *old_gov = data->governor;
1678
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001679 pr_debug("governor switch\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680
1681 /* end old governor */
Andrej Gelenbergffe62752010-05-14 15:15:58 -07001682 if (data->governor)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
1684
1685 /* start new governor */
1686 data->governor = policy->governor;
1687 if (__cpufreq_governor(data, CPUFREQ_GOV_START)) {
1688 /* new governor failed, so re-start old one */
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001689 pr_debug("starting governor %s failed\n",
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301690 data->governor->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 if (old_gov) {
1692 data->governor = old_gov;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301693 __cpufreq_governor(data,
1694 CPUFREQ_GOV_START);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 }
1696 ret = -EINVAL;
1697 goto error_out;
1698 }
1699 /* might be a policy change, too, so fall through */
1700 }
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001701 pr_debug("governor: change or update limits\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
1703 }
1704
Dave Jones7d5e3502006-02-02 17:03:42 -05001705error_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706 return ret;
1707}
1708
1709/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710 * cpufreq_update_policy - re-evaluate an existing cpufreq policy
1711 * @cpu: CPU which shall be re-evaluated
1712 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001713 * Useful for policy notifiers which have different necessities
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 * at different times.
1715 */
1716int cpufreq_update_policy(unsigned int cpu)
1717{
1718 struct cpufreq_policy *data = cpufreq_cpu_get(cpu);
1719 struct cpufreq_policy policy;
Julia Lawallf1829e42008-07-25 22:44:53 +02001720 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721
Julia Lawallf1829e42008-07-25 22:44:53 +02001722 if (!data) {
1723 ret = -ENODEV;
1724 goto no_policy;
1725 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726
Julia Lawallf1829e42008-07-25 22:44:53 +02001727 if (unlikely(lock_policy_rwsem_write(cpu))) {
1728 ret = -EINVAL;
1729 goto fail;
1730 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001732 pr_debug("updating policy for CPU %u\n", cpu);
Dave Jones7d5e3502006-02-02 17:03:42 -05001733 memcpy(&policy, data, sizeof(struct cpufreq_policy));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 policy.min = data->user_policy.min;
1735 policy.max = data->user_policy.max;
1736 policy.policy = data->user_policy.policy;
1737 policy.governor = data->user_policy.governor;
1738
Thomas Renninger0961dd02006-01-26 18:46:33 +01001739 /* BIOS might change freq behind our back
1740 -> ask driver for current freq and notify governors about a change */
1741 if (cpufreq_driver->get) {
1742 policy.cur = cpufreq_driver->get(cpu);
Thomas Renningera85f7bd2006-02-01 11:36:04 +01001743 if (!data->cur) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001744 pr_debug("Driver did not initialize current freq");
Thomas Renningera85f7bd2006-02-01 11:36:04 +01001745 data->cur = policy.cur;
1746 } else {
1747 if (data->cur != policy.cur)
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301748 cpufreq_out_of_sync(cpu, data->cur,
1749 policy.cur);
Thomas Renningera85f7bd2006-02-01 11:36:04 +01001750 }
Thomas Renninger0961dd02006-01-26 18:46:33 +01001751 }
1752
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 ret = __cpufreq_set_policy(data, &policy);
1754
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001755 unlock_policy_rwsem_write(cpu);
1756
Julia Lawallf1829e42008-07-25 22:44:53 +02001757fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 cpufreq_cpu_put(data);
Julia Lawallf1829e42008-07-25 22:44:53 +02001759no_policy:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 return ret;
1761}
1762EXPORT_SYMBOL(cpufreq_update_policy);
1763
Satyam Sharmadd184a02007-10-02 13:28:14 -07001764static int __cpuinit cpufreq_cpu_callback(struct notifier_block *nfb,
Ashok Rajc32b6b82005-10-30 14:59:54 -08001765 unsigned long action, void *hcpu)
1766{
1767 unsigned int cpu = (unsigned long)hcpu;
Ashok Rajc32b6b82005-10-30 14:59:54 -08001768 struct sys_device *sys_dev;
1769
1770 sys_dev = get_cpu_sysdev(cpu);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001771 if (sys_dev) {
1772 switch (action) {
1773 case CPU_ONLINE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001774 case CPU_ONLINE_FROZEN:
Ashok Rajc32b6b82005-10-30 14:59:54 -08001775 cpufreq_add_dev(sys_dev);
1776 break;
1777 case CPU_DOWN_PREPARE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001778 case CPU_DOWN_PREPARE_FROZEN:
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001779 if (unlikely(lock_policy_rwsem_write(cpu)))
1780 BUG();
1781
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001782 __cpufreq_remove_dev(sys_dev);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001783 break;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001784 case CPU_DOWN_FAILED:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07001785 case CPU_DOWN_FAILED_FROZEN:
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001786 cpufreq_add_dev(sys_dev);
Ashok Rajc32b6b82005-10-30 14:59:54 -08001787 break;
1788 }
1789 }
1790 return NOTIFY_OK;
1791}
1792
Neal Buckendahl9c36f742010-06-22 22:02:44 -05001793static struct notifier_block __refdata cpufreq_cpu_notifier = {
Ashok Rajc32b6b82005-10-30 14:59:54 -08001794 .notifier_call = cpufreq_cpu_callback,
1795};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796
1797/*********************************************************************
1798 * REGISTER / UNREGISTER CPUFREQ DRIVER *
1799 *********************************************************************/
1800
1801/**
1802 * cpufreq_register_driver - register a CPU Frequency driver
1803 * @driver_data: A struct cpufreq_driver containing the values#
1804 * submitted by the CPU Frequency driver.
1805 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001806 * Registers a CPU Frequency driver to this core code. This code
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 * returns zero on success, -EBUSY when another driver got here first
Dave Jones32ee8c32006-02-28 00:43:23 -05001808 * (and isn't unregistered in the meantime).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809 *
1810 */
Linus Torvalds221dee22007-02-26 14:55:48 -08001811int cpufreq_register_driver(struct cpufreq_driver *driver_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812{
1813 unsigned long flags;
1814 int ret;
1815
1816 if (!driver_data || !driver_data->verify || !driver_data->init ||
1817 ((!driver_data->setpolicy) && (!driver_data->target)))
1818 return -EINVAL;
1819
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001820 pr_debug("trying to register driver %s\n", driver_data->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821
1822 if (driver_data->setpolicy)
1823 driver_data->flags |= CPUFREQ_CONST_LOOPS;
1824
1825 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1826 if (cpufreq_driver) {
1827 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1828 return -EBUSY;
1829 }
1830 cpufreq_driver = driver_data;
1831 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1832
Mike Travis7a6aedf2008-03-25 15:06:53 -07001833 ret = sysdev_driver_register(&cpu_sysdev_class,
1834 &cpufreq_sysdev_driver);
Jiri Slaby8f5bc2a2011-03-01 17:41:10 +01001835 if (ret)
1836 goto err_null_driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837
Jiri Slaby8f5bc2a2011-03-01 17:41:10 +01001838 if (!(cpufreq_driver->flags & CPUFREQ_STICKY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 int i;
1840 ret = -ENODEV;
1841
1842 /* check for at least one working CPU */
Mike Travis7a6aedf2008-03-25 15:06:53 -07001843 for (i = 0; i < nr_cpu_ids; i++)
1844 if (cpu_possible(i) && per_cpu(cpufreq_cpu_data, i)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 ret = 0;
Mike Travis7a6aedf2008-03-25 15:06:53 -07001846 break;
1847 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848
1849 /* if all ->init() calls failed, unregister */
1850 if (ret) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001851 pr_debug("no CPU initialized for driver %s\n",
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301852 driver_data->name);
Jiri Slaby8f5bc2a2011-03-01 17:41:10 +01001853 goto err_sysdev_unreg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 }
1855 }
1856
Jiri Slaby8f5bc2a2011-03-01 17:41:10 +01001857 register_hotcpu_notifier(&cpufreq_cpu_notifier);
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001858 pr_debug("driver %s up and running\n", driver_data->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859
Jiri Slaby8f5bc2a2011-03-01 17:41:10 +01001860 return 0;
1861err_sysdev_unreg:
1862 sysdev_driver_unregister(&cpu_sysdev_class,
1863 &cpufreq_sysdev_driver);
1864err_null_driver:
1865 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1866 cpufreq_driver = NULL;
1867 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
Dave Jones4d34a672008-02-07 16:33:49 -05001868 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869}
1870EXPORT_SYMBOL_GPL(cpufreq_register_driver);
1871
1872
1873/**
1874 * cpufreq_unregister_driver - unregister the current CPUFreq driver
1875 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001876 * Unregister the current CPUFreq driver. Only call this if you have
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 * the right to do so, i.e. if you have succeeded in initialising before!
1878 * Returns zero if successful, and -EINVAL if the cpufreq_driver is
1879 * currently not initialised.
1880 */
Linus Torvalds221dee22007-02-26 14:55:48 -08001881int cpufreq_unregister_driver(struct cpufreq_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882{
1883 unsigned long flags;
1884
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001885 if (!cpufreq_driver || (driver != cpufreq_driver))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001888 pr_debug("unregistering driver %s\n", driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889
1890 sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver);
Chandra Seetharaman65edc682006-06-27 02:54:08 -07001891 unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892
1893 spin_lock_irqsave(&cpufreq_driver_lock, flags);
1894 cpufreq_driver = NULL;
1895 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1896
1897 return 0;
1898}
1899EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001900
1901static int __init cpufreq_core_init(void)
1902{
1903 int cpu;
1904
1905 for_each_possible_cpu(cpu) {
Tejun Heof1625062009-10-29 22:34:13 +09001906 per_cpu(cpufreq_policy_cpu, cpu) = -1;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001907 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
1908 }
Thomas Renninger8aa84ad2009-07-24 15:25:05 +02001909
1910 cpufreq_global_kobject = kobject_create_and_add("cpufreq",
1911 &cpu_sysdev_class.kset.kobj);
1912 BUG_ON(!cpufreq_global_kobject);
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001913 register_syscore_ops(&cpufreq_syscore_ops);
Thomas Renninger8aa84ad2009-07-24 15:25:05 +02001914
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001915 return 0;
1916}
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001917core_initcall(cpufreq_core_init);