blob: c35e7da1ed7a185fd95d0f0ae7f7b2961d235a0f [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>
Viresh Kumarbb176f72013-06-19 14:19:33 +05306 * (C) 2013 Viresh Kumar <viresh.kumar@linaro.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
Ashok Rajc32b6b82005-10-30 14:59:54 -08008 * Oct 2005 - Ashok Raj <ashok.raj@intel.com>
Dave Jones32ee8c32006-02-28 00:43:23 -05009 * Added handling for CPU hotplug
Dave Jones8ff69732006-03-05 03:37:23 -050010 * Feb 2006 - Jacob Shin <jacob.shin@amd.com>
11 * Fix handling for CPU hotplug -- affected CPUs
Ashok Rajc32b6b82005-10-30 14:59:54 -080012 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License version 2 as
15 * published by the Free Software Foundation.
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 */
17
Viresh Kumardb701152012-10-23 01:29:03 +020018#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19
Viresh Kumar5ff0a262013-08-06 22:53:03 +053020#include <linux/cpu.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/cpufreq.h>
22#include <linux/delay.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/device.h>
Viresh Kumar5ff0a262013-08-06 22:53:03 +053024#include <linux/init.h>
25#include <linux/kernel_stat.h>
26#include <linux/module.h>
akpm@osdl.org3fc54d32006-01-13 15:54:22 -080027#include <linux/mutex.h>
Viresh Kumar5ff0a262013-08-06 22:53:03 +053028#include <linux/slab.h>
Viresh Kumar2f0aea92014-03-04 11:00:26 +080029#include <linux/suspend.h>
Doug Anderson90de2a42014-12-23 22:09:48 -080030#include <linux/syscore_ops.h>
Viresh Kumar5ff0a262013-08-06 22:53:03 +053031#include <linux/tick.h>
Thomas Renninger6f4f2722010-04-20 13:17:36 +020032#include <trace/events/power.h>
33
Viresh Kumarb4f06762015-01-27 14:06:08 +053034static LIST_HEAD(cpufreq_policy_list);
Viresh Kumarf9637352015-05-12 12:20:11 +053035
36static inline bool policy_is_inactive(struct cpufreq_policy *policy)
37{
38 return cpumask_empty(policy->cpus);
39}
40
41static bool suitable_policy(struct cpufreq_policy *policy, bool active)
42{
43 return active == !policy_is_inactive(policy);
44}
45
46/* Finds Next Acive/Inactive policy */
47static struct cpufreq_policy *next_policy(struct cpufreq_policy *policy,
48 bool active)
49{
50 do {
51 policy = list_next_entry(policy, policy_list);
52
53 /* No more policies in the list */
54 if (&policy->policy_list == &cpufreq_policy_list)
55 return NULL;
56 } while (!suitable_policy(policy, active));
57
58 return policy;
59}
60
61static struct cpufreq_policy *first_policy(bool active)
62{
63 struct cpufreq_policy *policy;
64
65 /* No policies in the list */
66 if (list_empty(&cpufreq_policy_list))
67 return NULL;
68
69 policy = list_first_entry(&cpufreq_policy_list, typeof(*policy),
70 policy_list);
71
72 if (!suitable_policy(policy, active))
73 policy = next_policy(policy, active);
74
75 return policy;
76}
77
78/* Macros to iterate over CPU policies */
79#define for_each_suitable_policy(__policy, __active) \
80 for (__policy = first_policy(__active); \
81 __policy; \
82 __policy = next_policy(__policy, __active))
83
84#define for_each_active_policy(__policy) \
85 for_each_suitable_policy(__policy, true)
86#define for_each_inactive_policy(__policy) \
87 for_each_suitable_policy(__policy, false)
88
89#define for_each_policy(__policy) \
Viresh Kumarb4f06762015-01-27 14:06:08 +053090 list_for_each_entry(__policy, &cpufreq_policy_list, policy_list)
91
Viresh Kumarf7b27062015-01-27 14:06:09 +053092/* Iterate over governors */
93static LIST_HEAD(cpufreq_governor_list);
94#define for_each_governor(__governor) \
95 list_for_each_entry(__governor, &cpufreq_governor_list, governor_list)
96
Linus Torvalds1da177e2005-04-16 15:20:36 -070097/**
Dave Jonescd878472006-08-11 17:59:28 -040098 * The "cpufreq driver" - the arch- or hardware-dependent low
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 * level driver of CPUFreq support, and its spinlock. This lock
100 * also protects the cpufreq_cpu_data array.
101 */
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +0200102static struct cpufreq_driver *cpufreq_driver;
Mike Travis7a6aedf2008-03-25 15:06:53 -0700103static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
Viresh Kumarbb176f72013-06-19 14:19:33 +0530104static DEFINE_RWLOCK(cpufreq_driver_lock);
Jane Li6f1e4ef2014-01-03 17:17:41 +0800105DEFINE_MUTEX(cpufreq_governor_lock);
Viresh Kumarbb176f72013-06-19 14:19:33 +0530106
Viresh Kumar2f0aea92014-03-04 11:00:26 +0800107/* Flag to suspend/resume CPUFreq governors */
108static bool cpufreq_suspended;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530110static inline bool has_target(void)
111{
112 return cpufreq_driver->target_index || cpufreq_driver->target;
113}
114
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115/* internal prototypes */
Dave Jones29464f22009-01-18 01:37:11 -0500116static int __cpufreq_governor(struct cpufreq_policy *policy,
117 unsigned int event);
Viresh Kumard92d50a2015-01-02 12:34:29 +0530118static unsigned int __cpufreq_get(struct cpufreq_policy *policy);
David Howells65f27f32006-11-22 14:55:48 +0000119static void handle_update(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
121/**
Dave Jones32ee8c32006-02-28 00:43:23 -0500122 * Two notifier lists: the "policy" list is involved in the
123 * validation process for a new CPU frequency policy; the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 * "transition" list for kernel code that needs to handle
125 * changes to devices when the CPU clock speed changes.
126 * The mutex locks both lists.
127 */
Alan Sterne041c682006-03-27 01:16:30 -0800128static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700129static struct srcu_notifier_head cpufreq_transition_notifier_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
Cesar Eduardo Barros74212ca2008-02-16 08:41:24 -0200131static bool init_cpufreq_transition_notifier_list_called;
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700132static int __init init_cpufreq_transition_notifier_list(void)
133{
134 srcu_init_notifier_head(&cpufreq_transition_notifier_list);
Cesar Eduardo Barros74212ca2008-02-16 08:41:24 -0200135 init_cpufreq_transition_notifier_list_called = true;
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700136 return 0;
137}
Linus Torvaldsb3438f82006-11-20 11:47:18 -0800138pure_initcall(init_cpufreq_transition_notifier_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
Konrad Rzeszutek Wilka7b422c2012-03-13 19:18:39 -0400140static int off __read_mostly;
Viresh Kumarda584452012-10-26 00:51:32 +0200141static int cpufreq_disabled(void)
Konrad Rzeszutek Wilka7b422c2012-03-13 19:18:39 -0400142{
143 return off;
144}
145void disable_cpufreq(void)
146{
147 off = 1;
148}
Dave Jones29464f22009-01-18 01:37:11 -0500149static DEFINE_MUTEX(cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
Viresh Kumar4d5dcc42013-03-27 15:58:58 +0000151bool have_governor_per_policy(void)
152{
Viresh Kumar0b981e72013-10-02 14:13:18 +0530153 return !!(cpufreq_driver->flags & CPUFREQ_HAVE_GOVERNOR_PER_POLICY);
Viresh Kumar4d5dcc42013-03-27 15:58:58 +0000154}
Viresh Kumar3f869d62013-05-16 05:09:56 +0000155EXPORT_SYMBOL_GPL(have_governor_per_policy);
Viresh Kumar4d5dcc42013-03-27 15:58:58 +0000156
Viresh Kumar944e9a02013-05-16 05:09:57 +0000157struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy)
158{
159 if (have_governor_per_policy())
160 return &policy->kobj;
161 else
162 return cpufreq_global_kobject;
163}
164EXPORT_SYMBOL_GPL(get_governor_parent_kobj);
165
Viresh Kumar5a31d592015-07-10 01:43:27 +0200166struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu)
167{
168 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
169
170 return policy && !policy_is_inactive(policy) ?
171 policy->freq_table : NULL;
172}
173EXPORT_SYMBOL_GPL(cpufreq_frequency_get_table);
174
Viresh Kumar72a4ce32013-05-17 11:26:32 +0000175static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall)
176{
177 u64 idle_time;
178 u64 cur_wall_time;
179 u64 busy_time;
180
181 cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());
182
183 busy_time = kcpustat_cpu(cpu).cpustat[CPUTIME_USER];
184 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM];
185 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_IRQ];
186 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SOFTIRQ];
187 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_STEAL];
188 busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_NICE];
189
190 idle_time = cur_wall_time - busy_time;
191 if (wall)
192 *wall = cputime_to_usecs(cur_wall_time);
193
194 return cputime_to_usecs(idle_time);
195}
196
197u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy)
198{
199 u64 idle_time = get_cpu_idle_time_us(cpu, io_busy ? wall : NULL);
200
201 if (idle_time == -1ULL)
202 return get_cpu_idle_time_jiffy(cpu, wall);
203 else if (!io_busy)
204 idle_time += get_cpu_iowait_time_us(cpu, wall);
205
206 return idle_time;
207}
208EXPORT_SYMBOL_GPL(get_cpu_idle_time);
209
Viresh Kumar70e9e772013-10-03 20:29:07 +0530210/*
211 * This is a generic cpufreq init() routine which can be used by cpufreq
212 * drivers of SMP systems. It will do following:
213 * - validate & show freq table passed
214 * - set policies transition latency
215 * - policy->cpus with all possible CPUs
216 */
217int cpufreq_generic_init(struct cpufreq_policy *policy,
218 struct cpufreq_frequency_table *table,
219 unsigned int transition_latency)
220{
221 int ret;
222
223 ret = cpufreq_table_validate_and_show(policy, table);
224 if (ret) {
225 pr_err("%s: invalid frequency table: %d\n", __func__, ret);
226 return ret;
227 }
228
229 policy->cpuinfo.transition_latency = transition_latency;
230
231 /*
Shailendra Verma58405af2015-05-22 22:48:22 +0530232 * The driver only supports the SMP configuration where all processors
Viresh Kumar70e9e772013-10-03 20:29:07 +0530233 * share the clock and voltage and clock.
234 */
235 cpumask_setall(policy->cpus);
236
237 return 0;
238}
239EXPORT_SYMBOL_GPL(cpufreq_generic_init);
240
Rafael J. Wysocki1f0bd442015-09-16 02:17:49 +0200241struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu)
Viresh Kumar652ed952014-01-09 20:38:43 +0530242{
243 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
244
Viresh Kumar988bed02015-05-08 11:53:45 +0530245 return policy && cpumask_test_cpu(cpu, policy->cpus) ? policy : NULL;
246}
Rafael J. Wysocki1f0bd442015-09-16 02:17:49 +0200247EXPORT_SYMBOL_GPL(cpufreq_cpu_get_raw);
Viresh Kumar988bed02015-05-08 11:53:45 +0530248
249unsigned int cpufreq_generic_get(unsigned int cpu)
250{
251 struct cpufreq_policy *policy = cpufreq_cpu_get_raw(cpu);
252
Viresh Kumar652ed952014-01-09 20:38:43 +0530253 if (!policy || IS_ERR(policy->clk)) {
Joe Perchese837f9b2014-03-11 10:03:00 -0700254 pr_err("%s: No %s associated to cpu: %d\n",
255 __func__, policy ? "clk" : "policy", cpu);
Viresh Kumar652ed952014-01-09 20:38:43 +0530256 return 0;
257 }
258
259 return clk_get_rate(policy->clk) / 1000;
260}
261EXPORT_SYMBOL_GPL(cpufreq_generic_get);
262
Viresh Kumar50e9c852015-02-19 17:02:03 +0530263/**
264 * cpufreq_cpu_get: returns policy for a cpu and marks it busy.
265 *
266 * @cpu: cpu to find policy for.
267 *
268 * This returns policy for 'cpu', returns NULL if it doesn't exist.
269 * It also increments the kobject reference count to mark it busy and so would
270 * require a corresponding call to cpufreq_cpu_put() to decrement it back.
271 * If corresponding call cpufreq_cpu_put() isn't made, the policy wouldn't be
272 * freed as that depends on the kobj count.
273 *
Viresh Kumar50e9c852015-02-19 17:02:03 +0530274 * Return: A valid policy on success, otherwise NULL on failure.
275 */
Viresh Kumar6eed9402013-08-06 22:53:11 +0530276struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277{
Viresh Kumar6eed9402013-08-06 22:53:11 +0530278 struct cpufreq_policy *policy = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 unsigned long flags;
280
Viresh Kumar1b947c92015-02-19 17:02:05 +0530281 if (WARN_ON(cpu >= nr_cpu_ids))
Viresh Kumar6eed9402013-08-06 22:53:11 +0530282 return NULL;
283
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 /* get the cpufreq driver */
Nathan Zimmer0d1857a2013-02-22 16:24:34 +0000285 read_lock_irqsave(&cpufreq_driver_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
Viresh Kumar6eed9402013-08-06 22:53:11 +0530287 if (cpufreq_driver) {
288 /* get the CPU */
Viresh Kumar988bed02015-05-08 11:53:45 +0530289 policy = cpufreq_cpu_get_raw(cpu);
Viresh Kumar6eed9402013-08-06 22:53:11 +0530290 if (policy)
291 kobject_get(&policy->kobj);
292 }
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +0200293
Viresh Kumar6eed9402013-08-06 22:53:11 +0530294 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
Viresh Kumar3a3e9e02013-08-06 22:53:05 +0530296 return policy;
Stephen Boyda9144432012-07-20 18:14:38 +0000297}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
299
Viresh Kumar50e9c852015-02-19 17:02:03 +0530300/**
301 * cpufreq_cpu_put: Decrements the usage count of a policy
302 *
303 * @policy: policy earlier returned by cpufreq_cpu_get().
304 *
305 * This decrements the kobject reference count incremented earlier by calling
306 * cpufreq_cpu_get().
Viresh Kumar50e9c852015-02-19 17:02:03 +0530307 */
Viresh Kumar3a3e9e02013-08-06 22:53:05 +0530308void cpufreq_cpu_put(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309{
Viresh Kumar6eed9402013-08-06 22:53:11 +0530310 kobject_put(&policy->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311}
312EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
313
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314/*********************************************************************
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 * EXTERNALLY AFFECTING FREQUENCY CHANGES *
316 *********************************************************************/
317
318/**
319 * adjust_jiffies - adjust the system "loops_per_jiffy"
320 *
321 * This function alters the system "loops_per_jiffy" for the clock
322 * speed change. Note that loops_per_jiffy cannot be updated on SMP
Dave Jones32ee8c32006-02-28 00:43:23 -0500323 * systems as each CPU might be scaled differently. So, use the arch
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 * per-CPU loops_per_jiffy value wherever possible.
325 */
Arjan van de Ven858119e2006-01-14 13:20:43 -0800326static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327{
Viresh Kumar39c132e2015-01-02 12:34:34 +0530328#ifndef CONFIG_SMP
329 static unsigned long l_p_j_ref;
330 static unsigned int l_p_j_ref_freq;
331
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 if (ci->flags & CPUFREQ_CONST_LOOPS)
333 return;
334
335 if (!l_p_j_ref_freq) {
336 l_p_j_ref = loops_per_jiffy;
337 l_p_j_ref_freq = ci->old;
Joe Perchese837f9b2014-03-11 10:03:00 -0700338 pr_debug("saving %lu as reference value for loops_per_jiffy; freq is %u kHz\n",
339 l_p_j_ref, l_p_j_ref_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 }
Viresh Kumar0b443ea2014-03-19 11:24:58 +0530341 if (val == CPUFREQ_POSTCHANGE && ci->old != ci->new) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530342 loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
343 ci->new);
Joe Perchese837f9b2014-03-11 10:03:00 -0700344 pr_debug("scaling loops_per_jiffy to %lu for frequency %u kHz\n",
345 loops_per_jiffy, ci->new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347#endif
Viresh Kumar39c132e2015-01-02 12:34:34 +0530348}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
Viresh Kumar0956df9c2013-06-19 14:19:34 +0530350static void __cpufreq_notify_transition(struct cpufreq_policy *policy,
Viresh Kumarb43a7ff2013-03-24 11:56:43 +0530351 struct cpufreq_freqs *freqs, unsigned int state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352{
353 BUG_ON(irqs_disabled());
354
Dirk Brandewied5aaffa2013-01-17 16:22:21 +0000355 if (cpufreq_disabled())
356 return;
357
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +0200358 freqs->flags = cpufreq_driver->flags;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200359 pr_debug("notification %u of frequency transition to %u kHz\n",
Joe Perchese837f9b2014-03-11 10:03:00 -0700360 state, freqs->new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 switch (state) {
Dave Jonese4472cb2006-01-31 15:53:55 -0800363
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 case CPUFREQ_PRECHANGE:
Dave Jones32ee8c32006-02-28 00:43:23 -0500365 /* detect if the driver reported a value as "old frequency"
Dave Jonese4472cb2006-01-31 15:53:55 -0800366 * which is not equal to what the cpufreq core thinks is
367 * "old frequency".
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 */
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +0200369 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
Dave Jonese4472cb2006-01-31 15:53:55 -0800370 if ((policy) && (policy->cpu == freqs->cpu) &&
371 (policy->cur) && (policy->cur != freqs->old)) {
Joe Perchese837f9b2014-03-11 10:03:00 -0700372 pr_debug("Warning: CPU frequency is %u, cpufreq assumed %u kHz\n",
373 freqs->old, policy->cur);
Dave Jonese4472cb2006-01-31 15:53:55 -0800374 freqs->old = policy->cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 }
376 }
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700377 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
Alan Sterne041c682006-03-27 01:16:30 -0800378 CPUFREQ_PRECHANGE, freqs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
380 break;
Dave Jonese4472cb2006-01-31 15:53:55 -0800381
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 case CPUFREQ_POSTCHANGE:
383 adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
Joe Perchese837f9b2014-03-11 10:03:00 -0700384 pr_debug("FREQ: %lu - CPU: %lu\n",
385 (unsigned long)freqs->new, (unsigned long)freqs->cpu);
Thomas Renninger25e41932011-01-03 17:50:44 +0100386 trace_cpu_frequency(freqs->new, freqs->cpu);
Alan Sternb4dfdbb2006-10-04 02:17:06 -0700387 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
Alan Sterne041c682006-03-27 01:16:30 -0800388 CPUFREQ_POSTCHANGE, freqs);
Dave Jonese4472cb2006-01-31 15:53:55 -0800389 if (likely(policy) && likely(policy->cpu == freqs->cpu))
390 policy->cur = freqs->new;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 break;
392 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393}
Viresh Kumarbb176f72013-06-19 14:19:33 +0530394
Viresh Kumarb43a7ff2013-03-24 11:56:43 +0530395/**
396 * cpufreq_notify_transition - call notifier chain and adjust_jiffies
397 * on frequency transition.
398 *
399 * This function calls the transition notifiers and the "adjust_jiffies"
400 * function. It is called twice on all CPU frequency changes that have
401 * external effects.
402 */
Viresh Kumar236a9802014-03-24 13:35:46 +0530403static void cpufreq_notify_transition(struct cpufreq_policy *policy,
Viresh Kumarb43a7ff2013-03-24 11:56:43 +0530404 struct cpufreq_freqs *freqs, unsigned int state)
405{
406 for_each_cpu(freqs->cpu, policy->cpus)
407 __cpufreq_notify_transition(policy, freqs, state);
408}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
Viresh Kumarf7ba3b42013-12-02 11:04:12 +0530410/* Do post notifications when there are chances that transition has failed */
Viresh Kumar236a9802014-03-24 13:35:46 +0530411static void cpufreq_notify_post_transition(struct cpufreq_policy *policy,
Viresh Kumarf7ba3b42013-12-02 11:04:12 +0530412 struct cpufreq_freqs *freqs, int transition_failed)
413{
414 cpufreq_notify_transition(policy, freqs, CPUFREQ_POSTCHANGE);
415 if (!transition_failed)
416 return;
417
418 swap(freqs->old, freqs->new);
419 cpufreq_notify_transition(policy, freqs, CPUFREQ_PRECHANGE);
420 cpufreq_notify_transition(policy, freqs, CPUFREQ_POSTCHANGE);
421}
Viresh Kumarf7ba3b42013-12-02 11:04:12 +0530422
Srivatsa S. Bhat12478cf2014-03-24 13:35:44 +0530423void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
424 struct cpufreq_freqs *freqs)
425{
Srivatsa S. Bhatca654dc2014-05-05 12:52:39 +0530426
427 /*
428 * Catch double invocations of _begin() which lead to self-deadlock.
429 * ASYNC_NOTIFICATION drivers are left out because the cpufreq core
430 * doesn't invoke _begin() on their behalf, and hence the chances of
431 * double invocations are very low. Moreover, there are scenarios
432 * where these checks can emit false-positive warnings in these
433 * drivers; so we avoid that by skipping them altogether.
434 */
435 WARN_ON(!(cpufreq_driver->flags & CPUFREQ_ASYNC_NOTIFICATION)
436 && current == policy->transition_task);
437
Srivatsa S. Bhat12478cf2014-03-24 13:35:44 +0530438wait:
439 wait_event(policy->transition_wait, !policy->transition_ongoing);
440
441 spin_lock(&policy->transition_lock);
442
443 if (unlikely(policy->transition_ongoing)) {
444 spin_unlock(&policy->transition_lock);
445 goto wait;
446 }
447
448 policy->transition_ongoing = true;
Srivatsa S. Bhatca654dc2014-05-05 12:52:39 +0530449 policy->transition_task = current;
Srivatsa S. Bhat12478cf2014-03-24 13:35:44 +0530450
451 spin_unlock(&policy->transition_lock);
452
453 cpufreq_notify_transition(policy, freqs, CPUFREQ_PRECHANGE);
454}
455EXPORT_SYMBOL_GPL(cpufreq_freq_transition_begin);
456
457void cpufreq_freq_transition_end(struct cpufreq_policy *policy,
458 struct cpufreq_freqs *freqs, int transition_failed)
459{
460 if (unlikely(WARN_ON(!policy->transition_ongoing)))
461 return;
462
463 cpufreq_notify_post_transition(policy, freqs, transition_failed);
464
465 policy->transition_ongoing = false;
Srivatsa S. Bhatca654dc2014-05-05 12:52:39 +0530466 policy->transition_task = NULL;
Srivatsa S. Bhat12478cf2014-03-24 13:35:44 +0530467
468 wake_up(&policy->transition_wait);
469}
470EXPORT_SYMBOL_GPL(cpufreq_freq_transition_end);
471
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473/*********************************************************************
474 * SYSFS INTERFACE *
475 *********************************************************************/
Rashika Kheria8a5c74a2014-02-26 22:12:42 +0530476static ssize_t show_boost(struct kobject *kobj,
Lukasz Majewski6f19efc2013-12-20 15:24:49 +0100477 struct attribute *attr, char *buf)
478{
479 return sprintf(buf, "%d\n", cpufreq_driver->boost_enabled);
480}
481
482static ssize_t store_boost(struct kobject *kobj, struct attribute *attr,
483 const char *buf, size_t count)
484{
485 int ret, enable;
486
487 ret = sscanf(buf, "%d", &enable);
488 if (ret != 1 || enable < 0 || enable > 1)
489 return -EINVAL;
490
491 if (cpufreq_boost_trigger_state(enable)) {
Joe Perchese837f9b2014-03-11 10:03:00 -0700492 pr_err("%s: Cannot %s BOOST!\n",
493 __func__, enable ? "enable" : "disable");
Lukasz Majewski6f19efc2013-12-20 15:24:49 +0100494 return -EINVAL;
495 }
496
Joe Perchese837f9b2014-03-11 10:03:00 -0700497 pr_debug("%s: cpufreq BOOST %s\n",
498 __func__, enable ? "enabled" : "disabled");
Lukasz Majewski6f19efc2013-12-20 15:24:49 +0100499
500 return count;
501}
502define_one_global_rw(boost);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
Viresh Kumar42f91fa2015-01-02 12:34:26 +0530504static struct cpufreq_governor *find_governor(const char *str_governor)
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700505{
506 struct cpufreq_governor *t;
507
Viresh Kumarf7b27062015-01-27 14:06:09 +0530508 for_each_governor(t)
Rasmus Villemoes7c4f4532014-09-29 15:50:11 +0200509 if (!strncasecmp(str_governor, t->name, CPUFREQ_NAME_LEN))
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700510 return t;
511
512 return NULL;
513}
514
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515/**
516 * cpufreq_parse_governor - parse a governor string
517 */
Dave Jones905d77c2008-03-05 14:28:32 -0500518static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 struct cpufreq_governor **governor)
520{
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700521 int err = -EINVAL;
522
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +0200523 if (cpufreq_driver->setpolicy) {
Rasmus Villemoes7c4f4532014-09-29 15:50:11 +0200524 if (!strncasecmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 *policy = CPUFREQ_POLICY_PERFORMANCE;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700526 err = 0;
Rasmus Villemoes7c4f4532014-09-29 15:50:11 +0200527 } else if (!strncasecmp(str_governor, "powersave",
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530528 CPUFREQ_NAME_LEN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 *policy = CPUFREQ_POLICY_POWERSAVE;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700530 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 }
Viresh Kumar2e1cc3a2015-01-02 12:34:27 +0530532 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 struct cpufreq_governor *t;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700534
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800535 mutex_lock(&cpufreq_governor_mutex);
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700536
Viresh Kumar42f91fa2015-01-02 12:34:26 +0530537 t = find_governor(str_governor);
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700538
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700539 if (t == NULL) {
Kees Cook1a8e1462011-05-04 08:38:56 -0700540 int ret;
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700541
Kees Cook1a8e1462011-05-04 08:38:56 -0700542 mutex_unlock(&cpufreq_governor_mutex);
543 ret = request_module("cpufreq_%s", str_governor);
544 mutex_lock(&cpufreq_governor_mutex);
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700545
Kees Cook1a8e1462011-05-04 08:38:56 -0700546 if (ret == 0)
Viresh Kumar42f91fa2015-01-02 12:34:26 +0530547 t = find_governor(str_governor);
Jeremy Fitzhardingeea714972006-07-06 12:32:01 -0700548 }
549
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700550 if (t != NULL) {
551 *governor = t;
552 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 }
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700554
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800555 mutex_unlock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 }
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -0700557 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560/**
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530561 * cpufreq_per_cpu_attr_read() / show_##file_name() -
562 * print out cpufreq information
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 *
564 * Write out information from cpufreq_driver->policy[cpu]; object must be
565 * "unsigned int".
566 */
567
Dave Jones32ee8c32006-02-28 00:43:23 -0500568#define show_one(file_name, object) \
569static ssize_t show_##file_name \
Dave Jones905d77c2008-03-05 14:28:32 -0500570(struct cpufreq_policy *policy, char *buf) \
Dave Jones32ee8c32006-02-28 00:43:23 -0500571{ \
Dave Jones29464f22009-01-18 01:37:11 -0500572 return sprintf(buf, "%u\n", policy->object); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573}
574
575show_one(cpuinfo_min_freq, cpuinfo.min_freq);
576show_one(cpuinfo_max_freq, cpuinfo.max_freq);
Thomas Renningered129782009-02-04 01:17:41 +0100577show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578show_one(scaling_min_freq, min);
579show_one(scaling_max_freq, max);
Dirk Brandewiec034b022014-10-13 08:37:40 -0700580
Viresh Kumar09347b22015-01-02 12:34:24 +0530581static ssize_t show_scaling_cur_freq(struct cpufreq_policy *policy, char *buf)
Dirk Brandewiec034b022014-10-13 08:37:40 -0700582{
583 ssize_t ret;
584
585 if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get)
586 ret = sprintf(buf, "%u\n", cpufreq_driver->get(policy->cpu));
587 else
588 ret = sprintf(buf, "%u\n", policy->cur);
589 return ret;
590}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591
Viresh Kumar037ce832013-10-02 14:13:16 +0530592static int cpufreq_set_policy(struct cpufreq_policy *policy,
Viresh Kumar3a3e9e02013-08-06 22:53:05 +0530593 struct cpufreq_policy *new_policy);
Thomas Renninger7970e082006-04-13 15:14:04 +0200594
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595/**
596 * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
597 */
598#define store_one(file_name, object) \
599static ssize_t store_##file_name \
Dave Jones905d77c2008-03-05 14:28:32 -0500600(struct cpufreq_policy *policy, const char *buf, size_t count) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601{ \
Vince Hsu619c144c2014-11-10 14:14:50 +0800602 int ret, temp; \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 struct cpufreq_policy new_policy; \
604 \
Viresh Kumar8fa5b632015-08-03 08:36:15 +0530605 memcpy(&new_policy, policy, sizeof(*policy)); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 \
Dave Jones29464f22009-01-18 01:37:11 -0500607 ret = sscanf(buf, "%u", &new_policy.object); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 if (ret != 1) \
609 return -EINVAL; \
610 \
Vince Hsu619c144c2014-11-10 14:14:50 +0800611 temp = new_policy.object; \
Viresh Kumar037ce832013-10-02 14:13:16 +0530612 ret = cpufreq_set_policy(policy, &new_policy); \
Vince Hsu619c144c2014-11-10 14:14:50 +0800613 if (!ret) \
614 policy->user_policy.object = temp; \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 \
616 return ret ? ret : count; \
617}
618
Dave Jones29464f22009-01-18 01:37:11 -0500619store_one(scaling_min_freq, min);
620store_one(scaling_max_freq, max);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
622/**
623 * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
624 */
Dave Jones905d77c2008-03-05 14:28:32 -0500625static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
626 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627{
Viresh Kumard92d50a2015-01-02 12:34:29 +0530628 unsigned int cur_freq = __cpufreq_get(policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 if (!cur_freq)
630 return sprintf(buf, "<unknown>");
631 return sprintf(buf, "%u\n", cur_freq);
632}
633
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634/**
635 * show_scaling_governor - show the current policy for the specified CPU
636 */
Dave Jones905d77c2008-03-05 14:28:32 -0500637static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638{
Dave Jones29464f22009-01-18 01:37:11 -0500639 if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 return sprintf(buf, "powersave\n");
641 else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
642 return sprintf(buf, "performance\n");
643 else if (policy->governor)
viresh kumar4b972f02012-10-23 01:23:43 +0200644 return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n",
Dave Jones29464f22009-01-18 01:37:11 -0500645 policy->governor->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 return -EINVAL;
647}
648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649/**
650 * store_scaling_governor - store policy for the specified CPU
651 */
Dave Jones905d77c2008-03-05 14:28:32 -0500652static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
653 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654{
Srivatsa S. Bhat5136fa52013-09-07 01:24:06 +0530655 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 char str_governor[16];
657 struct cpufreq_policy new_policy;
658
Viresh Kumar8fa5b632015-08-03 08:36:15 +0530659 memcpy(&new_policy, policy, sizeof(*policy));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660
Dave Jones29464f22009-01-18 01:37:11 -0500661 ret = sscanf(buf, "%15s", str_governor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 if (ret != 1)
663 return -EINVAL;
664
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530665 if (cpufreq_parse_governor(str_governor, &new_policy.policy,
666 &new_policy.governor))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 return -EINVAL;
668
Viresh Kumar037ce832013-10-02 14:13:16 +0530669 ret = cpufreq_set_policy(policy, &new_policy);
Viresh Kumar88dc4382015-08-03 08:36:18 +0530670 return ret ? ret : count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671}
672
673/**
674 * show_scaling_driver - show the cpufreq driver currently loaded
675 */
Dave Jones905d77c2008-03-05 14:28:32 -0500676static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677{
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +0200678 return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n", cpufreq_driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679}
680
681/**
682 * show_scaling_available_governors - show the available CPUfreq governors
683 */
Dave Jones905d77c2008-03-05 14:28:32 -0500684static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
685 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686{
687 ssize_t i = 0;
688 struct cpufreq_governor *t;
689
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530690 if (!has_target()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 i += sprintf(buf, "performance powersave");
692 goto out;
693 }
694
Viresh Kumarf7b27062015-01-27 14:06:09 +0530695 for_each_governor(t) {
Dave Jones29464f22009-01-18 01:37:11 -0500696 if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
697 - (CPUFREQ_NAME_LEN + 2)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 goto out;
viresh kumar4b972f02012-10-23 01:23:43 +0200699 i += scnprintf(&buf[i], CPUFREQ_NAME_PLEN, "%s ", t->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 }
Dave Jones7d5e3502006-02-02 17:03:42 -0500701out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 i += sprintf(&buf[i], "\n");
703 return i;
704}
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700705
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800706ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707{
708 ssize_t i = 0;
709 unsigned int cpu;
710
Rusty Russell835481d2009-01-04 05:18:06 -0800711 for_each_cpu(cpu, mask) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 if (i)
713 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
714 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
715 if (i >= (PAGE_SIZE - 5))
Dave Jones29464f22009-01-18 01:37:11 -0500716 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 }
718 i += sprintf(&buf[i], "\n");
719 return i;
720}
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800721EXPORT_SYMBOL_GPL(cpufreq_show_cpus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700723/**
724 * show_related_cpus - show the CPUs affected by each transition even if
725 * hw coordination is in use
726 */
727static ssize_t show_related_cpus(struct cpufreq_policy *policy, char *buf)
728{
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800729 return cpufreq_show_cpus(policy->related_cpus, buf);
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700730}
731
732/**
733 * show_affected_cpus - show the CPUs affected by each transition
734 */
735static ssize_t show_affected_cpus(struct cpufreq_policy *policy, char *buf)
736{
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800737 return cpufreq_show_cpus(policy->cpus, buf);
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700738}
739
Venki Pallipadi9e769882007-10-26 10:18:21 -0700740static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
Dave Jones905d77c2008-03-05 14:28:32 -0500741 const char *buf, size_t count)
Venki Pallipadi9e769882007-10-26 10:18:21 -0700742{
743 unsigned int freq = 0;
744 unsigned int ret;
745
CHIKAMA masaki879000f2008-06-05 22:46:33 -0700746 if (!policy->governor || !policy->governor->store_setspeed)
Venki Pallipadi9e769882007-10-26 10:18:21 -0700747 return -EINVAL;
748
749 ret = sscanf(buf, "%u", &freq);
750 if (ret != 1)
751 return -EINVAL;
752
753 policy->governor->store_setspeed(policy, freq);
754
755 return count;
756}
757
758static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
759{
CHIKAMA masaki879000f2008-06-05 22:46:33 -0700760 if (!policy->governor || !policy->governor->show_setspeed)
Venki Pallipadi9e769882007-10-26 10:18:21 -0700761 return sprintf(buf, "<unsupported>\n");
762
763 return policy->governor->show_setspeed(policy, buf);
764}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
Thomas Renningere2f74f32009-11-19 12:31:01 +0100766/**
viresh kumar8bf1ac722012-10-23 01:23:33 +0200767 * show_bios_limit - show the current cpufreq HW/BIOS limitation
Thomas Renningere2f74f32009-11-19 12:31:01 +0100768 */
769static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
770{
771 unsigned int limit;
772 int ret;
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +0200773 if (cpufreq_driver->bios_limit) {
774 ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
Thomas Renningere2f74f32009-11-19 12:31:01 +0100775 if (!ret)
776 return sprintf(buf, "%u\n", limit);
777 }
778 return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
779}
780
Borislav Petkov6dad2a22010-03-31 21:56:46 +0200781cpufreq_freq_attr_ro_perm(cpuinfo_cur_freq, 0400);
782cpufreq_freq_attr_ro(cpuinfo_min_freq);
783cpufreq_freq_attr_ro(cpuinfo_max_freq);
784cpufreq_freq_attr_ro(cpuinfo_transition_latency);
785cpufreq_freq_attr_ro(scaling_available_governors);
786cpufreq_freq_attr_ro(scaling_driver);
787cpufreq_freq_attr_ro(scaling_cur_freq);
788cpufreq_freq_attr_ro(bios_limit);
789cpufreq_freq_attr_ro(related_cpus);
790cpufreq_freq_attr_ro(affected_cpus);
791cpufreq_freq_attr_rw(scaling_min_freq);
792cpufreq_freq_attr_rw(scaling_max_freq);
793cpufreq_freq_attr_rw(scaling_governor);
794cpufreq_freq_attr_rw(scaling_setspeed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
Dave Jones905d77c2008-03-05 14:28:32 -0500796static struct attribute *default_attrs[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 &cpuinfo_min_freq.attr,
798 &cpuinfo_max_freq.attr,
Thomas Renningered129782009-02-04 01:17:41 +0100799 &cpuinfo_transition_latency.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 &scaling_min_freq.attr,
801 &scaling_max_freq.attr,
802 &affected_cpus.attr,
Darrick J. Wonge8628dd2008-04-18 13:31:12 -0700803 &related_cpus.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 &scaling_governor.attr,
805 &scaling_driver.attr,
806 &scaling_available_governors.attr,
Venki Pallipadi9e769882007-10-26 10:18:21 -0700807 &scaling_setspeed.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 NULL
809};
810
Dave Jones29464f22009-01-18 01:37:11 -0500811#define to_policy(k) container_of(k, struct cpufreq_policy, kobj)
812#define to_attr(a) container_of(a, struct freq_attr, attr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
Dave Jones29464f22009-01-18 01:37:11 -0500814static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815{
Dave Jones905d77c2008-03-05 14:28:32 -0500816 struct cpufreq_policy *policy = to_policy(kobj);
817 struct freq_attr *fattr = to_attr(attr);
Viresh Kumar1b750e32013-10-02 14:13:09 +0530818 ssize_t ret;
Viresh Kumar6eed9402013-08-06 22:53:11 +0530819
viresh kumarad7722d2013-10-18 19:10:15 +0530820 down_read(&policy->rwsem);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800821
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530822 if (fattr->show)
823 ret = fattr->show(policy, buf);
824 else
825 ret = -EIO;
826
viresh kumarad7722d2013-10-18 19:10:15 +0530827 up_read(&policy->rwsem);
Viresh Kumar1b750e32013-10-02 14:13:09 +0530828
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 return ret;
830}
831
Dave Jones905d77c2008-03-05 14:28:32 -0500832static ssize_t store(struct kobject *kobj, struct attribute *attr,
833 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834{
Dave Jones905d77c2008-03-05 14:28:32 -0500835 struct cpufreq_policy *policy = to_policy(kobj);
836 struct freq_attr *fattr = to_attr(attr);
Dave Jonesa07530b2008-03-05 14:22:25 -0500837 ssize_t ret = -EINVAL;
Viresh Kumar6eed9402013-08-06 22:53:11 +0530838
Srivatsa S. Bhat4f750c92013-09-07 01:23:43 +0530839 get_online_cpus();
840
841 if (!cpu_online(policy->cpu))
842 goto unlock;
843
viresh kumarad7722d2013-10-18 19:10:15 +0530844 down_write(&policy->rwsem);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -0800845
Gautham R Shenoye08f5f52006-10-26 16:20:58 +0530846 if (fattr->store)
847 ret = fattr->store(policy, buf, count);
848 else
849 ret = -EIO;
850
viresh kumarad7722d2013-10-18 19:10:15 +0530851 up_write(&policy->rwsem);
Srivatsa S. Bhat4f750c92013-09-07 01:23:43 +0530852unlock:
853 put_online_cpus();
854
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 return ret;
856}
857
Dave Jones905d77c2008-03-05 14:28:32 -0500858static void cpufreq_sysfs_release(struct kobject *kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859{
Dave Jones905d77c2008-03-05 14:28:32 -0500860 struct cpufreq_policy *policy = to_policy(kobj);
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200861 pr_debug("last reference is dropped\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 complete(&policy->kobj_unregister);
863}
864
Emese Revfy52cf25d2010-01-19 02:58:23 +0100865static const struct sysfs_ops sysfs_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 .show = show,
867 .store = store,
868};
869
870static struct kobj_type ktype_cpufreq = {
871 .sysfs_ops = &sysfs_ops,
872 .default_attrs = default_attrs,
873 .release = cpufreq_sysfs_release,
874};
875
Viresh Kumar87549142015-06-10 02:13:21 +0200876static int add_cpu_dev_symlink(struct cpufreq_policy *policy, int cpu)
877{
878 struct device *cpu_dev;
879
880 pr_debug("%s: Adding symlink for CPU: %u\n", __func__, cpu);
881
882 if (!policy)
883 return 0;
884
885 cpu_dev = get_cpu_device(cpu);
886 if (WARN_ON(!cpu_dev))
887 return 0;
888
889 return sysfs_create_link(&cpu_dev->kobj, &policy->kobj, "cpufreq");
890}
891
892static void remove_cpu_dev_symlink(struct cpufreq_policy *policy, int cpu)
893{
894 struct device *cpu_dev;
895
896 pr_debug("%s: Removing symlink for CPU: %u\n", __func__, cpu);
897
898 cpu_dev = get_cpu_device(cpu);
899 if (WARN_ON(!cpu_dev))
900 return;
901
902 sysfs_remove_link(&cpu_dev->kobj, "cpufreq");
903}
904
905/* Add/remove symlinks for all related CPUs */
Viresh Kumar308b60e2013-07-31 14:35:14 +0200906static int cpufreq_add_dev_symlink(struct cpufreq_policy *policy)
Dave Jones19d6f7e2009-07-08 17:35:39 -0400907{
908 unsigned int j;
909 int ret = 0;
910
Viresh Kumar87549142015-06-10 02:13:21 +0200911 /* Some related CPUs might not be present (physically hotplugged) */
Rafael J. Wysocki559ed402015-07-26 02:07:47 +0200912 for_each_cpu(j, policy->real_cpus) {
Viresh Kumar87549142015-06-10 02:13:21 +0200913 ret = add_cpu_dev_symlink(policy, j);
Rafael J. Wysocki71c34612013-08-04 01:19:34 +0200914 if (ret)
915 break;
Dave Jones19d6f7e2009-07-08 17:35:39 -0400916 }
Viresh Kumar87549142015-06-10 02:13:21 +0200917
Dave Jones19d6f7e2009-07-08 17:35:39 -0400918 return ret;
919}
920
Viresh Kumar87549142015-06-10 02:13:21 +0200921static void cpufreq_remove_dev_symlink(struct cpufreq_policy *policy)
922{
923 unsigned int j;
924
925 /* Some related CPUs might not be present (physically hotplugged) */
Viresh Kumar96bdda62015-10-15 21:35:24 +0530926 for_each_cpu(j, policy->real_cpus)
Viresh Kumar87549142015-06-10 02:13:21 +0200927 remove_cpu_dev_symlink(policy, j);
Viresh Kumar87549142015-06-10 02:13:21 +0200928}
929
Rafael J. Wysockid9612a42015-07-27 23:11:37 +0200930static int cpufreq_add_dev_interface(struct cpufreq_policy *policy)
Dave Jones909a6942009-07-08 18:05:42 -0400931{
932 struct freq_attr **drv_attr;
Dave Jones909a6942009-07-08 18:05:42 -0400933 int ret = 0;
Dave Jones909a6942009-07-08 18:05:42 -0400934
Dave Jones909a6942009-07-08 18:05:42 -0400935 /* set up files for this cpu device */
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +0200936 drv_attr = cpufreq_driver->attr;
Viresh Kumarf13f1182015-01-02 12:34:23 +0530937 while (drv_attr && *drv_attr) {
Dave Jones909a6942009-07-08 18:05:42 -0400938 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
939 if (ret)
Tomeu Vizoso6d4e81e2014-11-24 10:08:03 +0100940 return ret;
Dave Jones909a6942009-07-08 18:05:42 -0400941 drv_attr++;
942 }
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +0200943 if (cpufreq_driver->get) {
Dave Jones909a6942009-07-08 18:05:42 -0400944 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
945 if (ret)
Tomeu Vizoso6d4e81e2014-11-24 10:08:03 +0100946 return ret;
Dave Jones909a6942009-07-08 18:05:42 -0400947 }
Dirk Brandewiec034b022014-10-13 08:37:40 -0700948
949 ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
950 if (ret)
Tomeu Vizoso6d4e81e2014-11-24 10:08:03 +0100951 return ret;
Dirk Brandewiec034b022014-10-13 08:37:40 -0700952
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +0200953 if (cpufreq_driver->bios_limit) {
Thomas Renningere2f74f32009-11-19 12:31:01 +0100954 ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
955 if (ret)
Tomeu Vizoso6d4e81e2014-11-24 10:08:03 +0100956 return ret;
Thomas Renningere2f74f32009-11-19 12:31:01 +0100957 }
Dave Jones909a6942009-07-08 18:05:42 -0400958
Tomeu Vizoso6d4e81e2014-11-24 10:08:03 +0100959 return cpufreq_add_dev_symlink(policy);
Srivatsa S. Bhate18f1682013-07-30 04:24:23 +0530960}
961
Viresh Kumar7f0fa402015-07-08 15:12:16 +0530962static int cpufreq_init_policy(struct cpufreq_policy *policy)
Srivatsa S. Bhate18f1682013-07-30 04:24:23 +0530963{
viresh kumar6e2c89d2014-03-04 11:43:59 +0800964 struct cpufreq_governor *gov = NULL;
Srivatsa S. Bhate18f1682013-07-30 04:24:23 +0530965 struct cpufreq_policy new_policy;
Srivatsa S. Bhate18f1682013-07-30 04:24:23 +0530966
Viresh Kumard5b73cd2013-08-06 22:53:06 +0530967 memcpy(&new_policy, policy, sizeof(*policy));
Jason Barona27a9ab2013-12-19 22:50:50 +0000968
viresh kumar6e2c89d2014-03-04 11:43:59 +0800969 /* Update governor of new_policy to the governor used before hotplug */
Viresh Kumar45732372015-05-12 12:22:34 +0530970 gov = find_governor(policy->last_governor);
viresh kumar6e2c89d2014-03-04 11:43:59 +0800971 if (gov)
972 pr_debug("Restoring governor %s for cpu %d\n",
973 policy->governor->name, policy->cpu);
974 else
975 gov = CPUFREQ_DEFAULT_GOVERNOR;
976
977 new_policy.governor = gov;
978
Srinivas Pandruvada69030dd2015-12-01 16:52:14 -0800979 /* Use the default policy if there is no last_policy. */
980 if (cpufreq_driver->setpolicy) {
981 if (policy->last_policy)
982 new_policy.policy = policy->last_policy;
983 else
984 cpufreq_parse_governor(gov->name, &new_policy.policy,
985 NULL);
986 }
Dave Jonesecf7e462009-07-08 18:48:47 -0400987 /* set default policy */
Viresh Kumar7f0fa402015-07-08 15:12:16 +0530988 return cpufreq_set_policy(policy, &new_policy);
Dave Jones909a6942009-07-08 18:05:42 -0400989}
990
Rafael J. Wysockid9612a42015-07-27 23:11:37 +0200991static int cpufreq_add_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
Viresh Kumarfcf80582013-01-29 14:39:08 +0000992{
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530993 int ret = 0;
Viresh Kumarfcf80582013-01-29 14:39:08 +0000994
Viresh Kumarbb29ae12015-02-19 17:02:06 +0530995 /* Has this CPU been taken care of already? */
996 if (cpumask_test_cpu(cpu, policy->cpus))
997 return 0;
998
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530999 if (has_target()) {
Viresh Kumar3de9bde2013-08-06 22:53:13 +05301000 ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
1001 if (ret) {
1002 pr_err("%s: Failed to stop governor\n", __func__);
1003 return ret;
1004 }
1005 }
Viresh Kumarfcf80582013-01-29 14:39:08 +00001006
viresh kumarad7722d2013-10-18 19:10:15 +05301007 down_write(&policy->rwsem);
Viresh Kumarfcf80582013-01-29 14:39:08 +00001008 cpumask_set_cpu(cpu, policy->cpus);
viresh kumarad7722d2013-10-18 19:10:15 +05301009 up_write(&policy->rwsem);
Viresh Kumar2eaa3e22013-02-07 10:55:00 +05301010
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +05301011 if (has_target()) {
Stratos Karafotise5c87b72014-03-19 23:29:17 +02001012 ret = __cpufreq_governor(policy, CPUFREQ_GOV_START);
1013 if (!ret)
1014 ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
1015
1016 if (ret) {
Viresh Kumar3de9bde2013-08-06 22:53:13 +05301017 pr_err("%s: Failed to start governor\n", __func__);
1018 return ret;
1019 }
Viresh Kumar820c6ca2013-04-22 00:48:03 +02001020 }
Viresh Kumarfcf80582013-01-29 14:39:08 +00001021
Viresh Kumar87549142015-06-10 02:13:21 +02001022 return 0;
Viresh Kumarfcf80582013-01-29 14:39:08 +00001023}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024
Rafael J. Wysockia34e63b2015-07-27 23:11:50 +02001025static struct cpufreq_policy *cpufreq_policy_alloc(unsigned int cpu)
Srivatsa S. Bhat84148092013-07-30 04:25:10 +05301026{
Rafael J. Wysockia34e63b2015-07-27 23:11:50 +02001027 struct device *dev = get_cpu_device(cpu);
Srivatsa S. Bhate9698cc2013-07-30 04:24:11 +05301028 struct cpufreq_policy *policy;
1029
Rafael J. Wysockia34e63b2015-07-27 23:11:50 +02001030 if (WARN_ON(!dev))
1031 return NULL;
1032
Srivatsa S. Bhate9698cc2013-07-30 04:24:11 +05301033 policy = kzalloc(sizeof(*policy), GFP_KERNEL);
1034 if (!policy)
1035 return NULL;
1036
1037 if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
1038 goto err_free_policy;
1039
1040 if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
1041 goto err_free_cpumask;
1042
Rafael J. Wysocki559ed402015-07-26 02:07:47 +02001043 if (!zalloc_cpumask_var(&policy->real_cpus, GFP_KERNEL))
1044 goto err_free_rcpumask;
1045
Viresh Kumar3510fac2015-10-16 12:41:12 +05301046 kobject_init(&policy->kobj, &ktype_cpufreq);
Lukasz Majewskic88a1f82013-08-06 22:53:08 +05301047 INIT_LIST_HEAD(&policy->policy_list);
viresh kumarad7722d2013-10-18 19:10:15 +05301048 init_rwsem(&policy->rwsem);
Srivatsa S. Bhat12478cf2014-03-24 13:35:44 +05301049 spin_lock_init(&policy->transition_lock);
1050 init_waitqueue_head(&policy->transition_wait);
Viresh Kumar818c5712015-01-02 12:34:38 +05301051 init_completion(&policy->kobj_unregister);
1052 INIT_WORK(&policy->update, handle_update);
viresh kumarad7722d2013-10-18 19:10:15 +05301053
Rafael J. Wysockia34e63b2015-07-27 23:11:50 +02001054 policy->cpu = cpu;
Srivatsa S. Bhate9698cc2013-07-30 04:24:11 +05301055 return policy;
1056
Viresh Kumar2fc33842015-06-08 18:25:29 +05301057err_free_rcpumask:
1058 free_cpumask_var(policy->related_cpus);
Srivatsa S. Bhate9698cc2013-07-30 04:24:11 +05301059err_free_cpumask:
1060 free_cpumask_var(policy->cpus);
1061err_free_policy:
1062 kfree(policy);
1063
1064 return NULL;
1065}
1066
Viresh Kumar2fc33842015-06-08 18:25:29 +05301067static void cpufreq_policy_put_kobj(struct cpufreq_policy *policy, bool notify)
Viresh Kumar42f921a2013-12-20 21:26:02 +05301068{
1069 struct kobject *kobj;
1070 struct completion *cmp;
1071
Viresh Kumar2fc33842015-06-08 18:25:29 +05301072 if (notify)
1073 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1074 CPUFREQ_REMOVE_POLICY, policy);
Viresh Kumarfcd7af92014-01-07 07:10:10 +05301075
Viresh Kumar87549142015-06-10 02:13:21 +02001076 down_write(&policy->rwsem);
1077 cpufreq_remove_dev_symlink(policy);
Viresh Kumar42f921a2013-12-20 21:26:02 +05301078 kobj = &policy->kobj;
1079 cmp = &policy->kobj_unregister;
Viresh Kumar87549142015-06-10 02:13:21 +02001080 up_write(&policy->rwsem);
Viresh Kumar42f921a2013-12-20 21:26:02 +05301081 kobject_put(kobj);
1082
1083 /*
1084 * We need to make sure that the underlying kobj is
1085 * actually not referenced anymore by anybody before we
1086 * proceed with unloading.
1087 */
1088 pr_debug("waiting for dropping of refcount\n");
1089 wait_for_completion(cmp);
1090 pr_debug("wait complete\n");
1091}
1092
Viresh Kumar3654c5c2015-06-08 18:25:30 +05301093static void cpufreq_policy_free(struct cpufreq_policy *policy, bool notify)
Srivatsa S. Bhate9698cc2013-07-30 04:24:11 +05301094{
Viresh Kumar988bed02015-05-08 11:53:45 +05301095 unsigned long flags;
1096 int cpu;
1097
1098 /* Remove policy from list */
1099 write_lock_irqsave(&cpufreq_driver_lock, flags);
1100 list_del(&policy->policy_list);
1101
1102 for_each_cpu(cpu, policy->related_cpus)
1103 per_cpu(cpufreq_cpu_data, cpu) = NULL;
1104 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1105
Viresh Kumar3654c5c2015-06-08 18:25:30 +05301106 cpufreq_policy_put_kobj(policy, notify);
Rafael J. Wysocki559ed402015-07-26 02:07:47 +02001107 free_cpumask_var(policy->real_cpus);
Srivatsa S. Bhate9698cc2013-07-30 04:24:11 +05301108 free_cpumask_var(policy->related_cpus);
1109 free_cpumask_var(policy->cpus);
1110 kfree(policy);
1111}
1112
Rafael J. Wysocki0b275352015-07-29 03:03:44 +02001113static int cpufreq_online(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114{
Viresh Kumar7f0c0202015-01-02 12:34:32 +05301115 struct cpufreq_policy *policy;
Rafael J. Wysocki194d99c2015-07-29 03:08:57 +02001116 bool new_policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 unsigned long flags;
Rafael J. Wysocki0b275352015-07-29 03:03:44 +02001118 unsigned int j;
1119 int ret;
Ashok Rajc32b6b82005-10-30 14:59:54 -08001120
Rafael J. Wysocki0b275352015-07-29 03:03:44 +02001121 pr_debug("%s: bringing CPU%u online\n", __func__, cpu);
Viresh Kumar6eed9402013-08-06 22:53:11 +05301122
Viresh Kumarbb29ae12015-02-19 17:02:06 +05301123 /* Check if this CPU already has a policy to manage it */
Viresh Kumar9104bb22015-05-12 12:22:12 +05301124 policy = per_cpu(cpufreq_cpu_data, cpu);
Rafael J. Wysocki11ce7072015-07-27 23:11:21 +02001125 if (policy) {
Viresh Kumar9104bb22015-05-12 12:22:12 +05301126 WARN_ON(!cpumask_test_cpu(cpu, policy->related_cpus));
Rafael J. Wysocki11ce7072015-07-27 23:11:21 +02001127 if (!policy_is_inactive(policy))
Rafael J. Wysockid9612a42015-07-27 23:11:37 +02001128 return cpufreq_add_policy_cpu(policy, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
Rafael J. Wysocki11ce7072015-07-27 23:11:21 +02001130 /* This is the only online CPU for the policy. Start over. */
Rafael J. Wysocki194d99c2015-07-29 03:08:57 +02001131 new_policy = false;
Rafael J. Wysocki11ce7072015-07-27 23:11:21 +02001132 down_write(&policy->rwsem);
1133 policy->cpu = cpu;
1134 policy->governor = NULL;
1135 up_write(&policy->rwsem);
1136 } else {
Rafael J. Wysocki194d99c2015-07-29 03:08:57 +02001137 new_policy = true;
Rafael J. Wysockia34e63b2015-07-27 23:11:50 +02001138 policy = cpufreq_policy_alloc(cpu);
Rafael J. Wysocki72368d12013-12-27 01:07:11 +01001139 if (!policy)
Rafael J. Wysockid4d854d2015-07-27 23:11:30 +02001140 return -ENOMEM;
Rafael J. Wysocki72368d12013-12-27 01:07:11 +01001141 }
Srivatsa S. Bhat0d66b912013-09-12 01:42:59 +05301142
Rusty Russell835481d2009-01-04 05:18:06 -08001143 cpumask_copy(policy->cpus, cpumask_of(cpu));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 /* call driver. From then on the cpufreq must be able
1146 * to accept all calls to ->verify and ->setpolicy for this CPU
1147 */
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +02001148 ret = cpufreq_driver->init(policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 if (ret) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001150 pr_debug("initialization failed\n");
Viresh Kumar8101f992015-07-08 15:12:15 +05301151 goto out_free_policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 }
Viresh Kumar643ae6e2013-01-12 05:14:38 +00001153
Tomeu Vizoso6d4e81e2014-11-24 10:08:03 +01001154 down_write(&policy->rwsem);
1155
Rafael J. Wysocki194d99c2015-07-29 03:08:57 +02001156 if (new_policy) {
Rafael J. Wysocki4d1f3a52015-07-27 23:11:44 +02001157 /* related_cpus should at least include policy->cpus. */
Viresh Kumar0998a032015-10-15 21:35:21 +05301158 cpumask_copy(policy->related_cpus, policy->cpus);
Rafael J. Wysocki4d1f3a52015-07-27 23:11:44 +02001159 /* Remember CPUs present at the policy creation time. */
Rafael J. Wysocki559ed402015-07-26 02:07:47 +02001160 cpumask_and(policy->real_cpus, policy->cpus, cpu_present_mask);
Viresh Kumar3510fac2015-10-16 12:41:12 +05301161
1162 /* Name and add the kobject */
1163 ret = kobject_add(&policy->kobj, cpufreq_global_kobject,
1164 "policy%u",
1165 cpumask_first(policy->related_cpus));
1166 if (ret) {
1167 pr_err("%s: failed to add policy->kobj: %d\n", __func__,
1168 ret);
1169 goto out_exit_policy;
1170 }
Rafael J. Wysocki4d1f3a52015-07-27 23:11:44 +02001171 }
Rafael J. Wysocki559ed402015-07-26 02:07:47 +02001172
Viresh Kumar5a7e56a2014-03-04 11:44:00 +08001173 /*
1174 * affected cpus must always be the one, which are online. We aren't
1175 * managing offline cpus here.
1176 */
1177 cpumask_and(policy->cpus, policy->cpus, cpu_online_mask);
1178
Rafael J. Wysocki194d99c2015-07-29 03:08:57 +02001179 if (new_policy) {
Viresh Kumar5a7e56a2014-03-04 11:44:00 +08001180 policy->user_policy.min = policy->min;
1181 policy->user_policy.max = policy->max;
Tomeu Vizoso6d4e81e2014-11-24 10:08:03 +01001182
Viresh Kumar988bed02015-05-08 11:53:45 +05301183 write_lock_irqsave(&cpufreq_driver_lock, flags);
1184 for_each_cpu(j, policy->related_cpus)
1185 per_cpu(cpufreq_cpu_data, j) = policy;
1186 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1187 }
Viresh Kumar652ed952014-01-09 20:38:43 +05301188
Rafael J. Wysocki2ed99e32014-03-12 21:49:33 +01001189 if (cpufreq_driver->get && !cpufreq_driver->setpolicy) {
Viresh Kumarda60ce92013-10-03 20:28:30 +05301190 policy->cur = cpufreq_driver->get(policy->cpu);
1191 if (!policy->cur) {
1192 pr_err("%s: ->get() failed\n", __func__);
Viresh Kumar8101f992015-07-08 15:12:15 +05301193 goto out_exit_policy;
Viresh Kumarda60ce92013-10-03 20:28:30 +05301194 }
1195 }
1196
Viresh Kumard3916692013-12-03 11:20:46 +05301197 /*
1198 * Sometimes boot loaders set CPU frequency to a value outside of
1199 * frequency table present with cpufreq core. In such cases CPU might be
1200 * unstable if it has to run on that frequency for long duration of time
1201 * and so its better to set it to a frequency which is specified in
1202 * freq-table. This also makes cpufreq stats inconsistent as
1203 * cpufreq-stats would fail to register because current frequency of CPU
1204 * isn't found in freq-table.
1205 *
1206 * Because we don't want this change to effect boot process badly, we go
1207 * for the next freq which is >= policy->cur ('cur' must be set by now,
1208 * otherwise we will end up setting freq to lowest of the table as 'cur'
1209 * is initialized to zero).
1210 *
1211 * We are passing target-freq as "policy->cur - 1" otherwise
1212 * __cpufreq_driver_target() would simply fail, as policy->cur will be
1213 * equal to target-freq.
1214 */
1215 if ((cpufreq_driver->flags & CPUFREQ_NEED_INITIAL_FREQ_CHECK)
1216 && has_target()) {
1217 /* Are we running at unknown frequency ? */
1218 ret = cpufreq_frequency_table_get_index(policy, policy->cur);
1219 if (ret == -EINVAL) {
1220 /* Warn user and fix it */
1221 pr_warn("%s: CPU%d: Running at unlisted freq: %u KHz\n",
1222 __func__, policy->cpu, policy->cur);
1223 ret = __cpufreq_driver_target(policy, policy->cur - 1,
1224 CPUFREQ_RELATION_L);
1225
1226 /*
1227 * Reaching here after boot in a few seconds may not
1228 * mean that system will remain stable at "unknown"
1229 * frequency for longer duration. Hence, a BUG_ON().
1230 */
1231 BUG_ON(ret);
1232 pr_warn("%s: CPU%d: Unlisted initial frequency changed to: %u KHz\n",
1233 __func__, policy->cpu, policy->cur);
1234 }
1235 }
1236
Thomas Renningera1531ac2008-07-29 22:32:58 -07001237 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1238 CPUFREQ_START, policy);
1239
Rafael J. Wysocki194d99c2015-07-29 03:08:57 +02001240 if (new_policy) {
Rafael J. Wysockid9612a42015-07-27 23:11:37 +02001241 ret = cpufreq_add_dev_interface(policy);
Srivatsa S. Bhata82fab22013-07-30 04:24:49 +05301242 if (ret)
Viresh Kumar8101f992015-07-08 15:12:15 +05301243 goto out_exit_policy;
Viresh Kumarfcd7af92014-01-07 07:10:10 +05301244 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1245 CPUFREQ_CREATE_POLICY, policy);
Dave Jones8ff69732006-03-05 03:37:23 -05001246
Viresh Kumar988bed02015-05-08 11:53:45 +05301247 write_lock_irqsave(&cpufreq_driver_lock, flags);
1248 list_add(&policy->policy_list, &cpufreq_policy_list);
1249 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1250 }
Viresh Kumar9515f4d2013-08-20 12:08:23 +05301251
Viresh Kumar7f0fa402015-07-08 15:12:16 +05301252 ret = cpufreq_init_policy(policy);
1253 if (ret) {
1254 pr_err("%s: Failed to initialize policy for cpu: %d (%d)\n",
1255 __func__, cpu, ret);
Rafael J. Wysocki194d99c2015-07-29 03:08:57 +02001256 /* cpufreq_policy_free() will notify based on this */
1257 new_policy = false;
1258 goto out_exit_policy;
Viresh Kumar08fd8c1c2013-12-24 07:11:01 +05301259 }
Srivatsa S. Bhate18f1682013-07-30 04:24:23 +05301260
Viresh Kumar4e97b632014-03-04 11:44:01 +08001261 up_write(&policy->rwsem);
Viresh Kumar08fd8c1c2013-12-24 07:11:01 +05301262
Greg Kroah-Hartman038c5b32007-12-17 15:54:39 -04001263 kobject_uevent(&policy->kobj, KOBJ_ADD);
Viresh Kumar7c45cf32014-11-27 06:07:51 +05301264
Viresh Kumar7c45cf32014-11-27 06:07:51 +05301265 /* Callback for handling stuff after policy is ready */
1266 if (cpufreq_driver->ready)
1267 cpufreq_driver->ready(policy);
1268
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001269 pr_debug("initialization complete\n");
Dave Jones87c32272006-03-29 01:48:37 -05001270
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 return 0;
1272
Viresh Kumar8101f992015-07-08 15:12:15 +05301273out_exit_policy:
Prarit Bhargava7106e022014-09-10 10:12:08 -04001274 up_write(&policy->rwsem);
1275
Viresh Kumarda60ce92013-10-03 20:28:30 +05301276 if (cpufreq_driver->exit)
1277 cpufreq_driver->exit(policy);
Viresh Kumar8101f992015-07-08 15:12:15 +05301278out_free_policy:
Rafael J. Wysocki194d99c2015-07-29 03:08:57 +02001279 cpufreq_policy_free(policy, !new_policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 return ret;
1281}
1282
Rafael J. Wysocki0b275352015-07-29 03:03:44 +02001283/**
1284 * cpufreq_add_dev - the cpufreq interface for a CPU device.
1285 * @dev: CPU device.
1286 * @sif: Subsystem interface structure pointer (not used)
1287 */
1288static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
1289{
1290 unsigned cpu = dev->id;
1291 int ret;
1292
1293 dev_dbg(dev, "%s: adding CPU%u\n", __func__, cpu);
1294
1295 if (cpu_online(cpu)) {
1296 ret = cpufreq_online(cpu);
1297 } else {
1298 /*
1299 * A hotplug notifier will follow and we will handle it as CPU
1300 * online then. For now, just create the sysfs link, unless
1301 * there is no policy or the link is already present.
1302 */
1303 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
1304
1305 ret = policy && !cpumask_test_and_set_cpu(cpu, policy->real_cpus)
1306 ? add_cpu_dev_symlink(policy, cpu) : 0;
1307 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
1309 return ret;
1310}
1311
Rafael J. Wysocki15c0b4d2015-07-27 23:11:09 +02001312static void cpufreq_offline_prepare(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313{
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05301314 struct cpufreq_policy *policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315
Viresh Kumarb8eed8a2013-01-14 13:23:03 +00001316 pr_debug("%s: unregistering CPU %u\n", __func__, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317
Viresh Kumar988bed02015-05-08 11:53:45 +05301318 policy = cpufreq_cpu_get_raw(cpu);
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05301319 if (!policy) {
Viresh Kumarb8eed8a2013-01-14 13:23:03 +00001320 pr_debug("%s: No cpu_data found\n", __func__);
Rafael J. Wysocki15c0b4d2015-07-27 23:11:09 +02001321 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +05301324 if (has_target()) {
Rafael J. Wysocki15c0b4d2015-07-27 23:11:09 +02001325 int ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
Rafael J. Wysocki559ed402015-07-26 02:07:47 +02001326 if (ret)
Viresh Kumar3de9bde2013-08-06 22:53:13 +05301327 pr_err("%s: Failed to stop governor\n", __func__);
Viresh Kumardb5f2992015-01-02 12:34:25 +05301328 }
Jacob Shin27ecddc2011-04-27 13:32:11 -05001329
Viresh Kumar45732372015-05-12 12:22:34 +05301330 down_write(&policy->rwsem);
Viresh Kumar9591bec2015-06-10 02:20:23 +02001331 cpumask_clear_cpu(cpu, policy->cpus);
Viresh Kumar45732372015-05-12 12:22:34 +05301332
Viresh Kumar9591bec2015-06-10 02:20:23 +02001333 if (policy_is_inactive(policy)) {
1334 if (has_target())
1335 strncpy(policy->last_governor, policy->governor->name,
1336 CPUFREQ_NAME_LEN);
Srinivas Pandruvada69030dd2015-12-01 16:52:14 -08001337 else
1338 policy->last_policy = policy->policy;
Viresh Kumar9591bec2015-06-10 02:20:23 +02001339 } else if (cpu == policy->cpu) {
1340 /* Nominate new CPU */
1341 policy->cpu = cpumask_any(policy->cpus);
1342 }
Viresh Kumar45732372015-05-12 12:22:34 +05301343 up_write(&policy->rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344
Viresh Kumar9591bec2015-06-10 02:20:23 +02001345 /* Start governor again for active policy */
1346 if (!policy_is_inactive(policy)) {
1347 if (has_target()) {
Rafael J. Wysocki15c0b4d2015-07-27 23:11:09 +02001348 int ret = __cpufreq_governor(policy, CPUFREQ_GOV_START);
Viresh Kumar9591bec2015-06-10 02:20:23 +02001349 if (!ret)
1350 ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
Viresh Kumar87549142015-06-10 02:13:21 +02001351
Viresh Kumar9591bec2015-06-10 02:20:23 +02001352 if (ret)
1353 pr_err("%s: Failed to start governor\n", __func__);
1354 }
1355 } else if (cpufreq_driver->stop_cpu) {
Dirk Brandewie367dc4a2014-03-19 08:45:53 -07001356 cpufreq_driver->stop_cpu(policy);
Viresh Kumar9591bec2015-06-10 02:20:23 +02001357 }
Srivatsa S. Bhatcedb70a2013-09-07 01:23:09 +05301358}
1359
Rafael J. Wysocki15c0b4d2015-07-27 23:11:09 +02001360static void cpufreq_offline_finish(unsigned int cpu)
Srivatsa S. Bhatcedb70a2013-09-07 01:23:09 +05301361{
Viresh Kumar9591bec2015-06-10 02:20:23 +02001362 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
Srivatsa S. Bhatcedb70a2013-09-07 01:23:09 +05301363
1364 if (!policy) {
1365 pr_debug("%s: No cpu_data found\n", __func__);
Rafael J. Wysocki15c0b4d2015-07-27 23:11:09 +02001366 return;
Srivatsa S. Bhatcedb70a2013-09-07 01:23:09 +05301367 }
1368
Viresh Kumar9591bec2015-06-10 02:20:23 +02001369 /* Only proceed for inactive policies */
1370 if (!policy_is_inactive(policy))
Rafael J. Wysocki15c0b4d2015-07-27 23:11:09 +02001371 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372
Viresh Kumar87549142015-06-10 02:13:21 +02001373 /* If cpu is last user of policy, free policy */
1374 if (has_target()) {
Rafael J. Wysocki15c0b4d2015-07-27 23:11:09 +02001375 int ret = __cpufreq_governor(policy, CPUFREQ_GOV_POLICY_EXIT);
Rafael J. Wysocki559ed402015-07-26 02:07:47 +02001376 if (ret)
Viresh Kumar87549142015-06-10 02:13:21 +02001377 pr_err("%s: Failed to exit governor\n", __func__);
Viresh Kumar87549142015-06-10 02:13:21 +02001378 }
1379
Viresh Kumar87549142015-06-10 02:13:21 +02001380 /*
1381 * Perform the ->exit() even during light-weight tear-down,
1382 * since this is a core component, and is essential for the
1383 * subsequent light-weight ->init() to succeed.
1384 */
Srinivas Pandruvada55582bc2015-10-07 13:50:44 -07001385 if (cpufreq_driver->exit) {
Viresh Kumar87549142015-06-10 02:13:21 +02001386 cpufreq_driver->exit(policy);
Srinivas Pandruvada55582bc2015-10-07 13:50:44 -07001387 policy->freq_table = NULL;
1388 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389}
1390
Srivatsa S. Bhatcedb70a2013-09-07 01:23:09 +05301391/**
Viresh Kumar27a862e2013-10-02 14:13:14 +05301392 * cpufreq_remove_dev - remove a CPU device
Srivatsa S. Bhatcedb70a2013-09-07 01:23:09 +05301393 *
1394 * Removes the cpufreq interface for a CPU device.
Srivatsa S. Bhatcedb70a2013-09-07 01:23:09 +05301395 */
Viresh Kumar71db87b2015-07-30 15:04:01 +05301396static void cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001397{
Kay Sievers8a25a2f2011-12-21 14:29:42 -08001398 unsigned int cpu = dev->id;
Rafael J. Wysocki559ed402015-07-26 02:07:47 +02001399 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
Venki Pallipadiec282972007-03-26 12:03:19 -07001400
Rafael J. Wysocki559ed402015-07-26 02:07:47 +02001401 if (!policy)
Linus Torvalds1af115d2015-08-31 08:47:40 -07001402 return;
Viresh Kumar87549142015-06-10 02:13:21 +02001403
Rafael J. Wysocki559ed402015-07-26 02:07:47 +02001404 if (cpu_online(cpu)) {
Rafael J. Wysocki15c0b4d2015-07-27 23:11:09 +02001405 cpufreq_offline_prepare(cpu);
1406 cpufreq_offline_finish(cpu);
Rafael J. Wysocki559ed402015-07-26 02:07:47 +02001407 }
Viresh Kumar87549142015-06-10 02:13:21 +02001408
Rafael J. Wysocki559ed402015-07-26 02:07:47 +02001409 cpumask_clear_cpu(cpu, policy->real_cpus);
Viresh Kumar96bdda62015-10-15 21:35:24 +05301410 remove_cpu_dev_symlink(policy, cpu);
Viresh Kumarf344dae2015-11-21 09:06:49 +05301411
1412 if (cpumask_empty(policy->real_cpus))
1413 cpufreq_policy_free(policy, true);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001414}
1415
David Howells65f27f32006-11-22 14:55:48 +00001416static void handle_update(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417{
David Howells65f27f32006-11-22 14:55:48 +00001418 struct cpufreq_policy *policy =
1419 container_of(work, struct cpufreq_policy, update);
1420 unsigned int cpu = policy->cpu;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001421 pr_debug("handle_update for cpu %u called\n", cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 cpufreq_update_policy(cpu);
1423}
1424
1425/**
Viresh Kumarbb176f72013-06-19 14:19:33 +05301426 * cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're
1427 * in deep trouble.
Viresh Kumara1e1dc42015-01-02 12:34:28 +05301428 * @policy: policy managing CPUs
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 * @new_freq: CPU frequency the CPU actually runs at
1430 *
Dave Jones29464f22009-01-18 01:37:11 -05001431 * We adjust to current frequency first, and need to clean up later.
1432 * So either call to cpufreq_update_policy() or schedule handle_update()).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 */
Viresh Kumara1e1dc42015-01-02 12:34:28 +05301434static void cpufreq_out_of_sync(struct cpufreq_policy *policy,
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301435 unsigned int new_freq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436{
1437 struct cpufreq_freqs freqs;
Viresh Kumarb43a7ff2013-03-24 11:56:43 +05301438
Joe Perchese837f9b2014-03-11 10:03:00 -07001439 pr_debug("Warning: CPU frequency out of sync: cpufreq and timing core thinks of %u, is %u kHz\n",
Viresh Kumara1e1dc42015-01-02 12:34:28 +05301440 policy->cur, new_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441
Viresh Kumara1e1dc42015-01-02 12:34:28 +05301442 freqs.old = policy->cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 freqs.new = new_freq;
Viresh Kumarb43a7ff2013-03-24 11:56:43 +05301444
Viresh Kumar8fec0512014-03-24 13:35:45 +05301445 cpufreq_freq_transition_begin(policy, &freqs);
1446 cpufreq_freq_transition_end(policy, &freqs, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447}
1448
Dave Jones32ee8c32006-02-28 00:43:23 -05001449/**
Dhaval Giani4ab70df2006-12-13 14:49:15 +05301450 * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001451 * @cpu: CPU number
1452 *
1453 * This is the last known freq, without actually getting it from the driver.
1454 * Return value will be same as what is shown in scaling_cur_freq in sysfs.
1455 */
1456unsigned int cpufreq_quick_get(unsigned int cpu)
1457{
Dirk Brandewie9e21ba82013-02-06 09:02:08 -08001458 struct cpufreq_policy *policy;
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301459 unsigned int ret_freq = 0;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001460
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +02001461 if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get)
1462 return cpufreq_driver->get(cpu);
Dirk Brandewie9e21ba82013-02-06 09:02:08 -08001463
1464 policy = cpufreq_cpu_get(cpu);
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001465 if (policy) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301466 ret_freq = policy->cur;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001467 cpufreq_cpu_put(policy);
1468 }
1469
Dave Jones4d34a672008-02-07 16:33:49 -05001470 return ret_freq;
Venkatesh Pallipadi95235ca2005-12-02 10:43:20 -08001471}
1472EXPORT_SYMBOL(cpufreq_quick_get);
1473
Jesse Barnes3d737102011-06-28 10:59:12 -07001474/**
1475 * cpufreq_quick_get_max - get the max reported CPU frequency for this CPU
1476 * @cpu: CPU number
1477 *
1478 * Just return the max possible frequency for a given CPU.
1479 */
1480unsigned int cpufreq_quick_get_max(unsigned int cpu)
1481{
1482 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1483 unsigned int ret_freq = 0;
1484
1485 if (policy) {
1486 ret_freq = policy->max;
1487 cpufreq_cpu_put(policy);
1488 }
1489
1490 return ret_freq;
1491}
1492EXPORT_SYMBOL(cpufreq_quick_get_max);
1493
Viresh Kumard92d50a2015-01-02 12:34:29 +05301494static unsigned int __cpufreq_get(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495{
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301496 unsigned int ret_freq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +02001498 if (!cpufreq_driver->get)
Dave Jones4d34a672008-02-07 16:33:49 -05001499 return ret_freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500
Viresh Kumard92d50a2015-01-02 12:34:29 +05301501 ret_freq = cpufreq_driver->get(policy->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502
Viresh Kumar11e584c2015-06-10 02:11:45 +02001503 /* Updating inactive policies is invalid, so avoid doing that. */
1504 if (unlikely(policy_is_inactive(policy)))
1505 return ret_freq;
1506
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301507 if (ret_freq && policy->cur &&
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +02001508 !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301509 /* verify no discrepancy between actual and
1510 saved value exists */
1511 if (unlikely(ret_freq != policy->cur)) {
Viresh Kumara1e1dc42015-01-02 12:34:28 +05301512 cpufreq_out_of_sync(policy, ret_freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 schedule_work(&policy->update);
1514 }
1515 }
1516
Dave Jones4d34a672008-02-07 16:33:49 -05001517 return ret_freq;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001518}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001520/**
1521 * cpufreq_get - get the current CPU frequency (in kHz)
1522 * @cpu: CPU number
1523 *
1524 * Get the CPU current (static) CPU frequency
1525 */
1526unsigned int cpufreq_get(unsigned int cpu)
1527{
Aaron Plattner999976e2014-03-04 12:42:15 -08001528 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001529 unsigned int ret_freq = 0;
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08001530
Aaron Plattner999976e2014-03-04 12:42:15 -08001531 if (policy) {
1532 down_read(&policy->rwsem);
Viresh Kumard92d50a2015-01-02 12:34:29 +05301533 ret_freq = __cpufreq_get(policy);
Aaron Plattner999976e2014-03-04 12:42:15 -08001534 up_read(&policy->rwsem);
Viresh Kumar26ca8692013-09-20 22:37:31 +05301535
Aaron Plattner999976e2014-03-04 12:42:15 -08001536 cpufreq_cpu_put(policy);
1537 }
Viresh Kumar6eed9402013-08-06 22:53:11 +05301538
Dave Jones4d34a672008-02-07 16:33:49 -05001539 return ret_freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540}
1541EXPORT_SYMBOL(cpufreq_get);
1542
Kay Sievers8a25a2f2011-12-21 14:29:42 -08001543static struct subsys_interface cpufreq_interface = {
1544 .name = "cpufreq",
1545 .subsys = &cpu_subsys,
1546 .add_dev = cpufreq_add_dev,
1547 .remove_dev = cpufreq_remove_dev,
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001548};
1549
Viresh Kumare28867e2014-03-04 11:00:27 +08001550/*
1551 * In case platform wants some specific frequency to be configured
1552 * during suspend..
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001553 */
Viresh Kumare28867e2014-03-04 11:00:27 +08001554int cpufreq_generic_suspend(struct cpufreq_policy *policy)
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001555{
Viresh Kumare28867e2014-03-04 11:00:27 +08001556 int ret;
Dave Jones4bc5d342009-08-04 14:03:25 -04001557
Viresh Kumare28867e2014-03-04 11:00:27 +08001558 if (!policy->suspend_freq) {
Bartlomiej Zolnierkiewicz201f3712015-09-08 18:41:02 +02001559 pr_debug("%s: suspend_freq not defined\n", __func__);
1560 return 0;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001561 }
1562
Viresh Kumare28867e2014-03-04 11:00:27 +08001563 pr_debug("%s: Setting suspend-freq: %u\n", __func__,
1564 policy->suspend_freq);
1565
1566 ret = __cpufreq_driver_target(policy, policy->suspend_freq,
1567 CPUFREQ_RELATION_H);
1568 if (ret)
1569 pr_err("%s: unable to set suspend-freq: %u. err: %d\n",
1570 __func__, policy->suspend_freq, ret);
1571
Dave Jonesc9060492008-02-07 16:32:18 -05001572 return ret;
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001573}
Viresh Kumare28867e2014-03-04 11:00:27 +08001574EXPORT_SYMBOL(cpufreq_generic_suspend);
Benjamin Herrenschmidt42d4dc32005-04-29 07:40:12 -07001575
1576/**
Viresh Kumar2f0aea92014-03-04 11:00:26 +08001577 * cpufreq_suspend() - Suspend CPUFreq governors
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 *
Viresh Kumar2f0aea92014-03-04 11:00:26 +08001579 * Called during system wide Suspend/Hibernate cycles for suspending governors
1580 * as some platforms can't change frequency after this point in suspend cycle.
1581 * Because some of the devices (like: i2c, regulators, etc) they use for
1582 * changing frequency are suspended quickly after this point.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 */
Viresh Kumar2f0aea92014-03-04 11:00:26 +08001584void cpufreq_suspend(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585{
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05301586 struct cpufreq_policy *policy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587
Viresh Kumar2f0aea92014-03-04 11:00:26 +08001588 if (!cpufreq_driver)
Rafael J. Wysockie00e56d2011-03-23 22:16:32 +01001589 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590
Viresh Kumar2f0aea92014-03-04 11:00:26 +08001591 if (!has_target())
Viresh Kumarb1b12ba2014-09-30 09:33:17 +05301592 goto suspend;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593
Viresh Kumar2f0aea92014-03-04 11:00:26 +08001594 pr_debug("%s: Suspending Governors\n", __func__);
1595
Viresh Kumarf9637352015-05-12 12:20:11 +05301596 for_each_active_policy(policy) {
Viresh Kumar2f0aea92014-03-04 11:00:26 +08001597 if (__cpufreq_governor(policy, CPUFREQ_GOV_STOP))
1598 pr_err("%s: Failed to stop governor for policy: %p\n",
1599 __func__, policy);
1600 else if (cpufreq_driver->suspend
1601 && cpufreq_driver->suspend(policy))
1602 pr_err("%s: Failed to suspend driver: %p\n", __func__,
1603 policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 }
Viresh Kumarb1b12ba2014-09-30 09:33:17 +05301605
1606suspend:
1607 cpufreq_suspended = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608}
1609
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610/**
Viresh Kumar2f0aea92014-03-04 11:00:26 +08001611 * cpufreq_resume() - Resume CPUFreq governors
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 *
Viresh Kumar2f0aea92014-03-04 11:00:26 +08001613 * Called during system wide Suspend/Hibernate cycle for resuming governors that
1614 * are suspended with cpufreq_suspend().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 */
Viresh Kumar2f0aea92014-03-04 11:00:26 +08001616void cpufreq_resume(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 struct cpufreq_policy *policy;
1619
Viresh Kumar2f0aea92014-03-04 11:00:26 +08001620 if (!cpufreq_driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 return;
1622
Lan Tianyu8e304442014-09-18 15:03:07 +08001623 cpufreq_suspended = false;
1624
Viresh Kumar2f0aea92014-03-04 11:00:26 +08001625 if (!has_target())
1626 return;
1627
1628 pr_debug("%s: Resuming Governors\n", __func__);
1629
Viresh Kumarf9637352015-05-12 12:20:11 +05301630 for_each_active_policy(policy) {
Viresh Kumar0c5aa402014-03-24 12:30:29 +05301631 if (cpufreq_driver->resume && cpufreq_driver->resume(policy))
1632 pr_err("%s: Failed to resume driver: %p\n", __func__,
1633 policy);
1634 else if (__cpufreq_governor(policy, CPUFREQ_GOV_START)
Viresh Kumar2f0aea92014-03-04 11:00:26 +08001635 || __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS))
1636 pr_err("%s: Failed to start governor for policy: %p\n",
1637 __func__, policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 }
Viresh Kumarc75de0a2015-04-02 10:21:33 +05301639
1640 /*
1641 * schedule call cpufreq_update_policy() for first-online CPU, as that
1642 * wouldn't be hotplugged-out on suspend. It will verify that the
1643 * current freq is in sync with what we believe it to be.
1644 */
1645 policy = cpufreq_cpu_get_raw(cpumask_first(cpu_online_mask));
1646 if (WARN_ON(!policy))
1647 return;
1648
1649 schedule_work(&policy->update);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651
Borislav Petkov9d950462013-01-20 10:24:28 +00001652/**
1653 * cpufreq_get_current_driver - return current driver's name
1654 *
1655 * Return the name string of the currently loaded cpufreq driver
1656 * or NULL, if none.
1657 */
1658const char *cpufreq_get_current_driver(void)
1659{
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +02001660 if (cpufreq_driver)
1661 return cpufreq_driver->name;
1662
1663 return NULL;
Borislav Petkov9d950462013-01-20 10:24:28 +00001664}
1665EXPORT_SYMBOL_GPL(cpufreq_get_current_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666
Thomas Petazzoni51315cd2014-10-19 11:30:27 +02001667/**
1668 * cpufreq_get_driver_data - return current driver data
1669 *
1670 * Return the private data of the currently loaded cpufreq
1671 * driver, or NULL if no cpufreq driver is loaded.
1672 */
1673void *cpufreq_get_driver_data(void)
1674{
1675 if (cpufreq_driver)
1676 return cpufreq_driver->driver_data;
1677
1678 return NULL;
1679}
1680EXPORT_SYMBOL_GPL(cpufreq_get_driver_data);
1681
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682/*********************************************************************
1683 * NOTIFIER LISTS INTERFACE *
1684 *********************************************************************/
1685
1686/**
1687 * cpufreq_register_notifier - register a driver with cpufreq
1688 * @nb: notifier function to register
1689 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1690 *
Dave Jones32ee8c32006-02-28 00:43:23 -05001691 * Add a driver to one of two lists: either a list of drivers that
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 * are notified about clock rate changes (once before and once after
1693 * the transition), or a list of drivers that are notified about
1694 * changes in cpufreq policy.
1695 *
1696 * This function may sleep, and has the same return conditions as
Alan Sterne041c682006-03-27 01:16:30 -08001697 * blocking_notifier_chain_register.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 */
1699int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1700{
1701 int ret;
1702
Dirk Brandewied5aaffa2013-01-17 16:22:21 +00001703 if (cpufreq_disabled())
1704 return -EINVAL;
1705
Cesar Eduardo Barros74212ca2008-02-16 08:41:24 -02001706 WARN_ON(!init_cpufreq_transition_notifier_list_called);
1707
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708 switch (list) {
1709 case CPUFREQ_TRANSITION_NOTIFIER:
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001710 ret = srcu_notifier_chain_register(
Alan Sterne041c682006-03-27 01:16:30 -08001711 &cpufreq_transition_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 break;
1713 case CPUFREQ_POLICY_NOTIFIER:
Alan Sterne041c682006-03-27 01:16:30 -08001714 ret = blocking_notifier_chain_register(
1715 &cpufreq_policy_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 break;
1717 default:
1718 ret = -EINVAL;
1719 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720
1721 return ret;
1722}
1723EXPORT_SYMBOL(cpufreq_register_notifier);
1724
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725/**
1726 * cpufreq_unregister_notifier - unregister a driver with cpufreq
1727 * @nb: notifier block to be unregistered
Viresh Kumarbb176f72013-06-19 14:19:33 +05301728 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 *
1730 * Remove a driver from the CPU frequency notifier list.
1731 *
1732 * This function may sleep, and has the same return conditions as
Alan Sterne041c682006-03-27 01:16:30 -08001733 * blocking_notifier_chain_unregister.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 */
1735int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1736{
1737 int ret;
1738
Dirk Brandewied5aaffa2013-01-17 16:22:21 +00001739 if (cpufreq_disabled())
1740 return -EINVAL;
1741
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 switch (list) {
1743 case CPUFREQ_TRANSITION_NOTIFIER:
Alan Sternb4dfdbb2006-10-04 02:17:06 -07001744 ret = srcu_notifier_chain_unregister(
Alan Sterne041c682006-03-27 01:16:30 -08001745 &cpufreq_transition_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 break;
1747 case CPUFREQ_POLICY_NOTIFIER:
Alan Sterne041c682006-03-27 01:16:30 -08001748 ret = blocking_notifier_chain_unregister(
1749 &cpufreq_policy_notifier_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 break;
1751 default:
1752 ret = -EINVAL;
1753 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754
1755 return ret;
1756}
1757EXPORT_SYMBOL(cpufreq_unregister_notifier);
1758
1759
1760/*********************************************************************
1761 * GOVERNORS *
1762 *********************************************************************/
1763
Viresh Kumar1c03a2d2014-06-02 22:49:28 +05301764/* Must set freqs->new to intermediate frequency */
1765static int __target_intermediate(struct cpufreq_policy *policy,
1766 struct cpufreq_freqs *freqs, int index)
1767{
1768 int ret;
1769
1770 freqs->new = cpufreq_driver->get_intermediate(policy, index);
1771
1772 /* We don't need to switch to intermediate freq */
1773 if (!freqs->new)
1774 return 0;
1775
1776 pr_debug("%s: cpu: %d, switching to intermediate freq: oldfreq: %u, intermediate freq: %u\n",
1777 __func__, policy->cpu, freqs->old, freqs->new);
1778
1779 cpufreq_freq_transition_begin(policy, freqs);
1780 ret = cpufreq_driver->target_intermediate(policy, index);
1781 cpufreq_freq_transition_end(policy, freqs, ret);
1782
1783 if (ret)
1784 pr_err("%s: Failed to change to intermediate frequency: %d\n",
1785 __func__, ret);
1786
1787 return ret;
1788}
1789
Viresh Kumar8d657752014-05-21 14:29:29 +05301790static int __target_index(struct cpufreq_policy *policy,
1791 struct cpufreq_frequency_table *freq_table, int index)
1792{
Viresh Kumar1c03a2d2014-06-02 22:49:28 +05301793 struct cpufreq_freqs freqs = {.old = policy->cur, .flags = 0};
1794 unsigned int intermediate_freq = 0;
Viresh Kumar8d657752014-05-21 14:29:29 +05301795 int retval = -EINVAL;
1796 bool notify;
1797
1798 notify = !(cpufreq_driver->flags & CPUFREQ_ASYNC_NOTIFICATION);
Viresh Kumar8d657752014-05-21 14:29:29 +05301799 if (notify) {
Viresh Kumar1c03a2d2014-06-02 22:49:28 +05301800 /* Handle switching to intermediate frequency */
1801 if (cpufreq_driver->get_intermediate) {
1802 retval = __target_intermediate(policy, &freqs, index);
1803 if (retval)
1804 return retval;
Viresh Kumar8d657752014-05-21 14:29:29 +05301805
Viresh Kumar1c03a2d2014-06-02 22:49:28 +05301806 intermediate_freq = freqs.new;
1807 /* Set old freq to intermediate */
1808 if (intermediate_freq)
1809 freqs.old = freqs.new;
1810 }
1811
1812 freqs.new = freq_table[index].frequency;
Viresh Kumar8d657752014-05-21 14:29:29 +05301813 pr_debug("%s: cpu: %d, oldfreq: %u, new freq: %u\n",
1814 __func__, policy->cpu, freqs.old, freqs.new);
1815
1816 cpufreq_freq_transition_begin(policy, &freqs);
1817 }
1818
1819 retval = cpufreq_driver->target_index(policy, index);
1820 if (retval)
1821 pr_err("%s: Failed to change cpu frequency: %d\n", __func__,
1822 retval);
1823
Viresh Kumar1c03a2d2014-06-02 22:49:28 +05301824 if (notify) {
Viresh Kumar8d657752014-05-21 14:29:29 +05301825 cpufreq_freq_transition_end(policy, &freqs, retval);
1826
Viresh Kumar1c03a2d2014-06-02 22:49:28 +05301827 /*
1828 * Failed after setting to intermediate freq? Driver should have
1829 * reverted back to initial frequency and so should we. Check
1830 * here for intermediate_freq instead of get_intermediate, in
Shailendra Verma58405af2015-05-22 22:48:22 +05301831 * case we haven't switched to intermediate freq at all.
Viresh Kumar1c03a2d2014-06-02 22:49:28 +05301832 */
1833 if (unlikely(retval && intermediate_freq)) {
1834 freqs.old = intermediate_freq;
1835 freqs.new = policy->restore_freq;
1836 cpufreq_freq_transition_begin(policy, &freqs);
1837 cpufreq_freq_transition_end(policy, &freqs, 0);
1838 }
1839 }
1840
Viresh Kumar8d657752014-05-21 14:29:29 +05301841 return retval;
1842}
1843
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844int __cpufreq_driver_target(struct cpufreq_policy *policy,
1845 unsigned int target_freq,
1846 unsigned int relation)
1847{
Viresh Kumar72499242012-10-31 01:28:21 +01001848 unsigned int old_target_freq = target_freq;
Viresh Kumar8d657752014-05-21 14:29:29 +05301849 int retval = -EINVAL;
Ashok Rajc32b6b82005-10-30 14:59:54 -08001850
Konrad Rzeszutek Wilka7b422c2012-03-13 19:18:39 -04001851 if (cpufreq_disabled())
1852 return -ENODEV;
1853
Viresh Kumar72499242012-10-31 01:28:21 +01001854 /* Make sure that target_freq is within supported range */
1855 if (target_freq > policy->max)
1856 target_freq = policy->max;
1857 if (target_freq < policy->min)
1858 target_freq = policy->min;
1859
1860 pr_debug("target for CPU %u: %u kHz, relation %u, requested %u kHz\n",
Joe Perchese837f9b2014-03-11 10:03:00 -07001861 policy->cpu, target_freq, relation, old_target_freq);
Viresh Kumar5a1c0222012-10-31 01:28:15 +01001862
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +05301863 /*
1864 * This might look like a redundant call as we are checking it again
1865 * after finding index. But it is left intentionally for cases where
1866 * exactly same freq is called again and so we can save on few function
1867 * calls.
1868 */
Viresh Kumar5a1c0222012-10-31 01:28:15 +01001869 if (target_freq == policy->cur)
1870 return 0;
1871
Viresh Kumar1c03a2d2014-06-02 22:49:28 +05301872 /* Save last value to restore later on errors */
1873 policy->restore_freq = policy->cur;
1874
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +02001875 if (cpufreq_driver->target)
1876 retval = cpufreq_driver->target(policy, target_freq, relation);
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +05301877 else if (cpufreq_driver->target_index) {
1878 struct cpufreq_frequency_table *freq_table;
1879 int index;
Ashok Raj90d45d12005-11-08 21:34:24 -08001880
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +05301881 freq_table = cpufreq_frequency_get_table(policy->cpu);
1882 if (unlikely(!freq_table)) {
1883 pr_err("%s: Unable to find freq_table\n", __func__);
1884 goto out;
1885 }
1886
1887 retval = cpufreq_frequency_table_target(policy, freq_table,
1888 target_freq, relation, &index);
1889 if (unlikely(retval)) {
1890 pr_err("%s: Unable to find matching freq\n", __func__);
1891 goto out;
1892 }
1893
Viresh Kumard4019f02013-08-14 19:38:24 +05301894 if (freq_table[index].frequency == policy->cur) {
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +05301895 retval = 0;
Viresh Kumard4019f02013-08-14 19:38:24 +05301896 goto out;
1897 }
1898
Viresh Kumar8d657752014-05-21 14:29:29 +05301899 retval = __target_index(policy, freq_table, index);
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +05301900 }
1901
1902out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 return retval;
1904}
1905EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1906
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907int cpufreq_driver_target(struct cpufreq_policy *policy,
1908 unsigned int target_freq,
1909 unsigned int relation)
1910{
Julia Lawallf1829e42008-07-25 22:44:53 +02001911 int ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912
viresh kumarad7722d2013-10-18 19:10:15 +05301913 down_write(&policy->rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914
1915 ret = __cpufreq_driver_target(policy, target_freq, relation);
1916
viresh kumarad7722d2013-10-18 19:10:15 +05301917 up_write(&policy->rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 return ret;
1920}
1921EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1922
Gautham R Shenoye08f5f52006-10-26 16:20:58 +05301923static int __cpufreq_governor(struct cpufreq_policy *policy,
1924 unsigned int event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925{
Dave Jonescc993ca2005-07-28 09:43:56 -07001926 int ret;
Thomas Renninger6afde102007-10-02 13:28:13 -07001927
1928 /* Only must be defined when default governor is known to have latency
1929 restrictions, like e.g. conservative or ondemand.
1930 That this is the case is already ensured in Kconfig
1931 */
1932#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
1933 struct cpufreq_governor *gov = &cpufreq_gov_performance;
1934#else
1935 struct cpufreq_governor *gov = NULL;
1936#endif
Thomas Renninger1c256242007-10-02 13:28:12 -07001937
Viresh Kumar2f0aea92014-03-04 11:00:26 +08001938 /* Don't start any governor operations if we are entering suspend */
1939 if (cpufreq_suspended)
1940 return 0;
Ethan Zhaocb577202014-12-18 15:28:19 +09001941 /*
1942 * Governor might not be initiated here if ACPI _PPC changed
1943 * notification happened, so check it.
1944 */
1945 if (!policy->governor)
1946 return -EINVAL;
Viresh Kumar2f0aea92014-03-04 11:00:26 +08001947
Thomas Renninger1c256242007-10-02 13:28:12 -07001948 if (policy->governor->max_transition_latency &&
1949 policy->cpuinfo.transition_latency >
1950 policy->governor->max_transition_latency) {
Thomas Renninger6afde102007-10-02 13:28:13 -07001951 if (!gov)
1952 return -EINVAL;
1953 else {
Joe Perchese837f9b2014-03-11 10:03:00 -07001954 pr_warn("%s governor failed, too long transition latency of HW, fallback to %s governor\n",
1955 policy->governor->name, gov->name);
Thomas Renninger6afde102007-10-02 13:28:13 -07001956 policy->governor = gov;
1957 }
Thomas Renninger1c256242007-10-02 13:28:12 -07001958 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959
Viresh Kumarfe492f32013-08-06 22:53:10 +05301960 if (event == CPUFREQ_GOV_POLICY_INIT)
1961 if (!try_module_get(policy->governor->owner))
1962 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963
Viresh Kumar63431f72015-07-27 17:58:06 +05301964 pr_debug("%s: for CPU %u, event %u\n", __func__, policy->cpu, event);
Xiaoguang Chen95731eb2013-06-19 15:00:07 +08001965
1966 mutex_lock(&cpufreq_governor_lock);
Srivatsa S. Bhat56d07db2013-09-07 01:23:55 +05301967 if ((policy->governor_enabled && event == CPUFREQ_GOV_START)
Viresh Kumarf73d3932013-08-31 17:53:40 +05301968 || (!policy->governor_enabled
1969 && (event == CPUFREQ_GOV_LIMITS || event == CPUFREQ_GOV_STOP))) {
Xiaoguang Chen95731eb2013-06-19 15:00:07 +08001970 mutex_unlock(&cpufreq_governor_lock);
1971 return -EBUSY;
1972 }
1973
1974 if (event == CPUFREQ_GOV_STOP)
1975 policy->governor_enabled = false;
1976 else if (event == CPUFREQ_GOV_START)
1977 policy->governor_enabled = true;
1978
1979 mutex_unlock(&cpufreq_governor_lock);
1980
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 ret = policy->governor->governor(policy, event);
1982
Viresh Kumar4d5dcc42013-03-27 15:58:58 +00001983 if (!ret) {
1984 if (event == CPUFREQ_GOV_POLICY_INIT)
1985 policy->governor->initialized++;
1986 else if (event == CPUFREQ_GOV_POLICY_EXIT)
1987 policy->governor->initialized--;
Xiaoguang Chen95731eb2013-06-19 15:00:07 +08001988 } else {
1989 /* Restore original values */
1990 mutex_lock(&cpufreq_governor_lock);
1991 if (event == CPUFREQ_GOV_STOP)
1992 policy->governor_enabled = true;
1993 else if (event == CPUFREQ_GOV_START)
1994 policy->governor_enabled = false;
1995 mutex_unlock(&cpufreq_governor_lock);
Viresh Kumar4d5dcc42013-03-27 15:58:58 +00001996 }
Viresh Kumarb3940582013-02-01 05:42:58 +00001997
Viresh Kumarfe492f32013-08-06 22:53:10 +05301998 if (((event == CPUFREQ_GOV_POLICY_INIT) && ret) ||
1999 ((event == CPUFREQ_GOV_POLICY_EXIT) && !ret))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 module_put(policy->governor->owner);
2001
2002 return ret;
2003}
2004
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005int cpufreq_register_governor(struct cpufreq_governor *governor)
2006{
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07002007 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008
2009 if (!governor)
2010 return -EINVAL;
2011
Konrad Rzeszutek Wilka7b422c2012-03-13 19:18:39 -04002012 if (cpufreq_disabled())
2013 return -ENODEV;
2014
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08002015 mutex_lock(&cpufreq_governor_mutex);
Dave Jones32ee8c32006-02-28 00:43:23 -05002016
Viresh Kumarb3940582013-02-01 05:42:58 +00002017 governor->initialized = 0;
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07002018 err = -EBUSY;
Viresh Kumar42f91fa2015-01-02 12:34:26 +05302019 if (!find_governor(governor->name)) {
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07002020 err = 0;
2021 list_add(&governor->governor_list, &cpufreq_governor_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023
Dave Jones32ee8c32006-02-28 00:43:23 -05002024 mutex_unlock(&cpufreq_governor_mutex);
Jeremy Fitzhardinge3bcb09a2006-07-06 12:30:26 -07002025 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026}
2027EXPORT_SYMBOL_GPL(cpufreq_register_governor);
2028
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029void cpufreq_unregister_governor(struct cpufreq_governor *governor)
2030{
Viresh Kumar45732372015-05-12 12:22:34 +05302031 struct cpufreq_policy *policy;
2032 unsigned long flags;
Prarit Bhargava90e41ba2009-11-12 09:18:46 -05002033
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034 if (!governor)
2035 return;
2036
Konrad Rzeszutek Wilka7b422c2012-03-13 19:18:39 -04002037 if (cpufreq_disabled())
2038 return;
2039
Viresh Kumar45732372015-05-12 12:22:34 +05302040 /* clear last_governor for all inactive policies */
2041 read_lock_irqsave(&cpufreq_driver_lock, flags);
2042 for_each_inactive_policy(policy) {
Viresh Kumar18bf3a12015-05-12 12:22:51 +05302043 if (!strcmp(policy->last_governor, governor->name)) {
2044 policy->governor = NULL;
Viresh Kumar45732372015-05-12 12:22:34 +05302045 strcpy(policy->last_governor, "\0");
Viresh Kumar18bf3a12015-05-12 12:22:51 +05302046 }
Prarit Bhargava90e41ba2009-11-12 09:18:46 -05002047 }
Viresh Kumar45732372015-05-12 12:22:34 +05302048 read_unlock_irqrestore(&cpufreq_driver_lock, flags);
Prarit Bhargava90e41ba2009-11-12 09:18:46 -05002049
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08002050 mutex_lock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051 list_del(&governor->governor_list);
akpm@osdl.org3fc54d32006-01-13 15:54:22 -08002052 mutex_unlock(&cpufreq_governor_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 return;
2054}
2055EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
2056
2057
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058/*********************************************************************
2059 * POLICY INTERFACE *
2060 *********************************************************************/
2061
2062/**
2063 * cpufreq_get_policy - get the current cpufreq_policy
Dave Jones29464f22009-01-18 01:37:11 -05002064 * @policy: struct cpufreq_policy into which the current cpufreq_policy
2065 * is written
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066 *
2067 * Reads the current cpufreq policy.
2068 */
2069int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
2070{
2071 struct cpufreq_policy *cpu_policy;
2072 if (!policy)
2073 return -EINVAL;
2074
2075 cpu_policy = cpufreq_cpu_get(cpu);
2076 if (!cpu_policy)
2077 return -EINVAL;
2078
Viresh Kumard5b73cd2013-08-06 22:53:06 +05302079 memcpy(policy, cpu_policy, sizeof(*policy));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080
2081 cpufreq_cpu_put(cpu_policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 return 0;
2083}
2084EXPORT_SYMBOL(cpufreq_get_policy);
2085
Arjan van de Ven153d7f32006-07-26 15:40:07 +02002086/*
Viresh Kumar037ce832013-10-02 14:13:16 +05302087 * policy : current policy.
2088 * new_policy: policy to be set.
Arjan van de Ven153d7f32006-07-26 15:40:07 +02002089 */
Viresh Kumar037ce832013-10-02 14:13:16 +05302090static int cpufreq_set_policy(struct cpufreq_policy *policy,
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05302091 struct cpufreq_policy *new_policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092{
Rafael J. Wysockid9a789c2014-02-17 22:56:35 +01002093 struct cpufreq_governor *old_gov;
2094 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095
Joe Perchese837f9b2014-03-11 10:03:00 -07002096 pr_debug("setting new policy for CPU %u: %u - %u kHz\n",
2097 new_policy->cpu, new_policy->min, new_policy->max);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098
Viresh Kumard5b73cd2013-08-06 22:53:06 +05302099 memcpy(&new_policy->cpuinfo, &policy->cpuinfo, sizeof(policy->cpuinfo));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100
Pan Xinhuifba95732015-07-30 18:10:40 +08002101 /*
2102 * This check works well when we store new min/max freq attributes,
2103 * because new_policy is a copy of policy with one field updated.
2104 */
2105 if (new_policy->min > new_policy->max)
Rafael J. Wysockid9a789c2014-02-17 22:56:35 +01002106 return -EINVAL;
Mattia Dongili9c9a43e2006-07-05 23:12:20 +02002107
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108 /* verify the cpu speed can be set within this limit */
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05302109 ret = cpufreq_driver->verify(new_policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110 if (ret)
Rafael J. Wysockid9a789c2014-02-17 22:56:35 +01002111 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113 /* adjust if necessary - all reasons */
Alan Sterne041c682006-03-27 01:16:30 -08002114 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05302115 CPUFREQ_ADJUST, new_policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116
Viresh Kumarbb176f72013-06-19 14:19:33 +05302117 /*
2118 * verify the cpu speed can be set within this limit, which might be
2119 * different to the first one
2120 */
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05302121 ret = cpufreq_driver->verify(new_policy);
Alan Sterne041c682006-03-27 01:16:30 -08002122 if (ret)
Rafael J. Wysockid9a789c2014-02-17 22:56:35 +01002123 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124
2125 /* notification of the new policy */
Alan Sterne041c682006-03-27 01:16:30 -08002126 blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05302127 CPUFREQ_NOTIFY, new_policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05302129 policy->min = new_policy->min;
2130 policy->max = new_policy->max;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02002132 pr_debug("new min and max freqs are %u - %u kHz\n",
Joe Perchese837f9b2014-03-11 10:03:00 -07002133 policy->min, policy->max);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +02002135 if (cpufreq_driver->setpolicy) {
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05302136 policy->policy = new_policy->policy;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02002137 pr_debug("setting range\n");
Rafael J. Wysockid9a789c2014-02-17 22:56:35 +01002138 return cpufreq_driver->setpolicy(new_policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139 }
2140
Rafael J. Wysockid9a789c2014-02-17 22:56:35 +01002141 if (new_policy->governor == policy->governor)
2142 goto out;
2143
2144 pr_debug("governor switch\n");
2145
2146 /* save old, working values */
2147 old_gov = policy->governor;
2148 /* end old governor */
2149 if (old_gov) {
Viresh Kumar4bc384a2015-07-18 11:31:03 +05302150 ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
2151 if (ret) {
2152 /* This can happen due to race with other operations */
2153 pr_debug("%s: Failed to Stop Governor: %s (%d)\n",
2154 __func__, old_gov->name, ret);
2155 return ret;
2156 }
2157
Rafael J. Wysockid9a789c2014-02-17 22:56:35 +01002158 up_write(&policy->rwsem);
Viresh Kumar4bc384a2015-07-18 11:31:03 +05302159 ret = __cpufreq_governor(policy, CPUFREQ_GOV_POLICY_EXIT);
Rafael J. Wysockid9a789c2014-02-17 22:56:35 +01002160 down_write(&policy->rwsem);
Viresh Kumar4bc384a2015-07-18 11:31:03 +05302161
2162 if (ret) {
2163 pr_err("%s: Failed to Exit Governor: %s (%d)\n",
2164 __func__, old_gov->name, ret);
2165 return ret;
2166 }
Rafael J. Wysockid9a789c2014-02-17 22:56:35 +01002167 }
2168
2169 /* start new governor */
2170 policy->governor = new_policy->governor;
Viresh Kumar4bc384a2015-07-18 11:31:03 +05302171 ret = __cpufreq_governor(policy, CPUFREQ_GOV_POLICY_INIT);
2172 if (!ret) {
2173 ret = __cpufreq_governor(policy, CPUFREQ_GOV_START);
2174 if (!ret)
Rafael J. Wysockid9a789c2014-02-17 22:56:35 +01002175 goto out;
2176
2177 up_write(&policy->rwsem);
2178 __cpufreq_governor(policy, CPUFREQ_GOV_POLICY_EXIT);
2179 down_write(&policy->rwsem);
2180 }
2181
2182 /* new governor failed, so re-start old one */
2183 pr_debug("starting governor %s failed\n", policy->governor->name);
2184 if (old_gov) {
2185 policy->governor = old_gov;
Viresh Kumar4bc384a2015-07-18 11:31:03 +05302186 if (__cpufreq_governor(policy, CPUFREQ_GOV_POLICY_INIT))
2187 policy->governor = NULL;
2188 else
2189 __cpufreq_governor(policy, CPUFREQ_GOV_START);
Rafael J. Wysockid9a789c2014-02-17 22:56:35 +01002190 }
2191
Viresh Kumar4bc384a2015-07-18 11:31:03 +05302192 return ret;
Rafael J. Wysockid9a789c2014-02-17 22:56:35 +01002193
2194 out:
2195 pr_debug("governor: change or update limits\n");
2196 return __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197}
2198
2199/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 * cpufreq_update_policy - re-evaluate an existing cpufreq policy
2201 * @cpu: CPU which shall be re-evaluated
2202 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002203 * Useful for policy notifiers which have different necessities
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204 * at different times.
2205 */
2206int cpufreq_update_policy(unsigned int cpu)
2207{
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05302208 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
2209 struct cpufreq_policy new_policy;
Julia Lawallf1829e42008-07-25 22:44:53 +02002210 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211
Aaron Plattnerfefa8ff2014-06-18 11:27:32 -07002212 if (!policy)
2213 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214
viresh kumarad7722d2013-10-18 19:10:15 +05302215 down_write(&policy->rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02002217 pr_debug("updating policy for CPU %u\n", cpu);
Viresh Kumard5b73cd2013-08-06 22:53:06 +05302218 memcpy(&new_policy, policy, sizeof(*policy));
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05302219 new_policy.min = policy->user_policy.min;
2220 new_policy.max = policy->user_policy.max;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221
Viresh Kumarbb176f72013-06-19 14:19:33 +05302222 /*
2223 * BIOS might change freq behind our back
2224 * -> ask driver for current freq and notify governors about a change
2225 */
Rafael J. Wysocki2ed99e32014-03-12 21:49:33 +01002226 if (cpufreq_driver->get && !cpufreq_driver->setpolicy) {
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05302227 new_policy.cur = cpufreq_driver->get(cpu);
Viresh Kumarbd0fa9b2014-02-25 14:29:44 +05302228 if (WARN_ON(!new_policy.cur)) {
2229 ret = -EIO;
Aaron Plattnerfefa8ff2014-06-18 11:27:32 -07002230 goto unlock;
Viresh Kumarbd0fa9b2014-02-25 14:29:44 +05302231 }
2232
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05302233 if (!policy->cur) {
Joe Perchese837f9b2014-03-11 10:03:00 -07002234 pr_debug("Driver did not initialize current freq\n");
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05302235 policy->cur = new_policy.cur;
Thomas Renningera85f7bd2006-02-01 11:36:04 +01002236 } else {
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +05302237 if (policy->cur != new_policy.cur && has_target())
Viresh Kumara1e1dc42015-01-02 12:34:28 +05302238 cpufreq_out_of_sync(policy, new_policy.cur);
Thomas Renningera85f7bd2006-02-01 11:36:04 +01002239 }
Thomas Renninger0961dd02006-01-26 18:46:33 +01002240 }
2241
Viresh Kumar037ce832013-10-02 14:13:16 +05302242 ret = cpufreq_set_policy(policy, &new_policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243
Aaron Plattnerfefa8ff2014-06-18 11:27:32 -07002244unlock:
viresh kumarad7722d2013-10-18 19:10:15 +05302245 up_write(&policy->rwsem);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08002246
Viresh Kumar3a3e9e02013-08-06 22:53:05 +05302247 cpufreq_cpu_put(policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248 return ret;
2249}
2250EXPORT_SYMBOL(cpufreq_update_policy);
2251
Paul Gortmaker27609842013-06-19 13:54:04 -04002252static int cpufreq_cpu_callback(struct notifier_block *nfb,
Ashok Rajc32b6b82005-10-30 14:59:54 -08002253 unsigned long action, void *hcpu)
2254{
2255 unsigned int cpu = (unsigned long)hcpu;
Ashok Rajc32b6b82005-10-30 14:59:54 -08002256
Rafael J. Wysocki0b275352015-07-29 03:03:44 +02002257 switch (action & ~CPU_TASKS_FROZEN) {
2258 case CPU_ONLINE:
2259 cpufreq_online(cpu);
2260 break;
Srivatsa S. Bhat5302c3f2013-07-30 04:25:25 +05302261
Rafael J. Wysocki0b275352015-07-29 03:03:44 +02002262 case CPU_DOWN_PREPARE:
2263 cpufreq_offline_prepare(cpu);
2264 break;
Srivatsa S. Bhat1aee40a2013-09-07 01:23:27 +05302265
Rafael J. Wysocki0b275352015-07-29 03:03:44 +02002266 case CPU_POST_DEAD:
2267 cpufreq_offline_finish(cpu);
2268 break;
Srivatsa S. Bhat5302c3f2013-07-30 04:25:25 +05302269
Rafael J. Wysocki0b275352015-07-29 03:03:44 +02002270 case CPU_DOWN_FAILED:
2271 cpufreq_online(cpu);
2272 break;
Ashok Rajc32b6b82005-10-30 14:59:54 -08002273 }
2274 return NOTIFY_OK;
2275}
2276
Neal Buckendahl9c36f742010-06-22 22:02:44 -05002277static struct notifier_block __refdata cpufreq_cpu_notifier = {
Viresh Kumarbb176f72013-06-19 14:19:33 +05302278 .notifier_call = cpufreq_cpu_callback,
Ashok Rajc32b6b82005-10-30 14:59:54 -08002279};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280
2281/*********************************************************************
Lukasz Majewski6f19efc2013-12-20 15:24:49 +01002282 * BOOST *
2283 *********************************************************************/
2284static int cpufreq_boost_set_sw(int state)
2285{
2286 struct cpufreq_frequency_table *freq_table;
2287 struct cpufreq_policy *policy;
2288 int ret = -EINVAL;
2289
Viresh Kumarf9637352015-05-12 12:20:11 +05302290 for_each_active_policy(policy) {
Lukasz Majewski6f19efc2013-12-20 15:24:49 +01002291 freq_table = cpufreq_frequency_get_table(policy->cpu);
2292 if (freq_table) {
2293 ret = cpufreq_frequency_table_cpuinfo(policy,
2294 freq_table);
2295 if (ret) {
2296 pr_err("%s: Policy frequency update failed\n",
2297 __func__);
2298 break;
2299 }
2300 policy->user_policy.max = policy->max;
2301 __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
2302 }
2303 }
2304
2305 return ret;
2306}
2307
2308int cpufreq_boost_trigger_state(int state)
2309{
2310 unsigned long flags;
2311 int ret = 0;
2312
2313 if (cpufreq_driver->boost_enabled == state)
2314 return 0;
2315
2316 write_lock_irqsave(&cpufreq_driver_lock, flags);
2317 cpufreq_driver->boost_enabled = state;
2318 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2319
2320 ret = cpufreq_driver->set_boost(state);
2321 if (ret) {
2322 write_lock_irqsave(&cpufreq_driver_lock, flags);
2323 cpufreq_driver->boost_enabled = !state;
2324 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2325
Joe Perchese837f9b2014-03-11 10:03:00 -07002326 pr_err("%s: Cannot %s BOOST\n",
2327 __func__, state ? "enable" : "disable");
Lukasz Majewski6f19efc2013-12-20 15:24:49 +01002328 }
2329
2330 return ret;
2331}
2332
Rafael J. Wysocki41669da2015-12-27 00:23:48 +01002333static bool cpufreq_boost_supported(void)
Lukasz Majewski6f19efc2013-12-20 15:24:49 +01002334{
Rafael J. Wysocki7a6c79f2015-12-27 00:27:38 +01002335 return likely(cpufreq_driver) && cpufreq_driver->set_boost;
Lukasz Majewski6f19efc2013-12-20 15:24:49 +01002336}
Lukasz Majewski6f19efc2013-12-20 15:24:49 +01002337
Viresh Kumar44139ed2015-07-29 16:23:09 +05302338static int create_boost_sysfs_file(void)
2339{
2340 int ret;
2341
Viresh Kumarc82bd442015-10-15 21:35:23 +05302342 ret = sysfs_create_file(cpufreq_global_kobject, &boost.attr);
Viresh Kumar44139ed2015-07-29 16:23:09 +05302343 if (ret)
2344 pr_err("%s: cannot register global BOOST sysfs file\n",
2345 __func__);
2346
2347 return ret;
2348}
2349
2350static void remove_boost_sysfs_file(void)
2351{
2352 if (cpufreq_boost_supported())
Viresh Kumarc82bd442015-10-15 21:35:23 +05302353 sysfs_remove_file(cpufreq_global_kobject, &boost.attr);
Viresh Kumar44139ed2015-07-29 16:23:09 +05302354}
2355
2356int cpufreq_enable_boost_support(void)
2357{
2358 if (!cpufreq_driver)
2359 return -EINVAL;
2360
2361 if (cpufreq_boost_supported())
2362 return 0;
2363
Rafael J. Wysocki7a6c79f2015-12-27 00:27:38 +01002364 cpufreq_driver->set_boost = cpufreq_boost_set_sw;
Viresh Kumar44139ed2015-07-29 16:23:09 +05302365
2366 /* This will get removed on driver unregister */
2367 return create_boost_sysfs_file();
2368}
2369EXPORT_SYMBOL_GPL(cpufreq_enable_boost_support);
2370
Lukasz Majewski6f19efc2013-12-20 15:24:49 +01002371int cpufreq_boost_enabled(void)
2372{
2373 return cpufreq_driver->boost_enabled;
2374}
2375EXPORT_SYMBOL_GPL(cpufreq_boost_enabled);
2376
2377/*********************************************************************
Linus Torvalds1da177e2005-04-16 15:20:36 -07002378 * REGISTER / UNREGISTER CPUFREQ DRIVER *
2379 *********************************************************************/
2380
2381/**
2382 * cpufreq_register_driver - register a CPU Frequency driver
2383 * @driver_data: A struct cpufreq_driver containing the values#
2384 * submitted by the CPU Frequency driver.
2385 *
Viresh Kumarbb176f72013-06-19 14:19:33 +05302386 * Registers a CPU Frequency driver to this core code. This code
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387 * returns zero on success, -EBUSY when another driver got here first
Dave Jones32ee8c32006-02-28 00:43:23 -05002388 * (and isn't unregistered in the meantime).
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389 *
2390 */
Linus Torvalds221dee22007-02-26 14:55:48 -08002391int cpufreq_register_driver(struct cpufreq_driver *driver_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392{
2393 unsigned long flags;
2394 int ret;
2395
Konrad Rzeszutek Wilka7b422c2012-03-13 19:18:39 -04002396 if (cpufreq_disabled())
2397 return -ENODEV;
2398
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399 if (!driver_data || !driver_data->verify || !driver_data->init ||
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +05302400 !(driver_data->setpolicy || driver_data->target_index ||
Rafael J. Wysocki98322352014-03-19 12:48:30 +01002401 driver_data->target) ||
2402 (driver_data->setpolicy && (driver_data->target_index ||
Viresh Kumar1c03a2d2014-06-02 22:49:28 +05302403 driver_data->target)) ||
2404 (!!driver_data->get_intermediate != !!driver_data->target_intermediate))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405 return -EINVAL;
2406
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02002407 pr_debug("trying to register driver %s\n", driver_data->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002408
Rafael J. Wysockifdd320d2015-07-30 01:45:07 +02002409 /* Protect against concurrent CPU online/offline. */
2410 get_online_cpus();
2411
Nathan Zimmer0d1857a2013-02-22 16:24:34 +00002412 write_lock_irqsave(&cpufreq_driver_lock, flags);
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +02002413 if (cpufreq_driver) {
Nathan Zimmer0d1857a2013-02-22 16:24:34 +00002414 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
Rafael J. Wysockifdd320d2015-07-30 01:45:07 +02002415 ret = -EEXIST;
2416 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417 }
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +02002418 cpufreq_driver = driver_data;
Nathan Zimmer0d1857a2013-02-22 16:24:34 +00002419 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420
Viresh Kumarbc68b7d2015-01-02 12:34:30 +05302421 if (driver_data->setpolicy)
2422 driver_data->flags |= CPUFREQ_CONST_LOOPS;
2423
Rafael J. Wysocki7a6c79f2015-12-27 00:27:38 +01002424 if (cpufreq_boost_supported()) {
2425 ret = create_boost_sysfs_file();
2426 if (ret)
2427 goto err_null_driver;
2428 }
Lukasz Majewski6f19efc2013-12-20 15:24:49 +01002429
Kay Sievers8a25a2f2011-12-21 14:29:42 -08002430 ret = subsys_interface_register(&cpufreq_interface);
Jiri Slaby8f5bc2a2011-03-01 17:41:10 +01002431 if (ret)
Lukasz Majewski6f19efc2013-12-20 15:24:49 +01002432 goto err_boost_unreg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433
Viresh Kumarce1bcfe2015-01-02 12:34:35 +05302434 if (!(cpufreq_driver->flags & CPUFREQ_STICKY) &&
2435 list_empty(&cpufreq_policy_list)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436 /* if all ->init() calls failed, unregister */
Viresh Kumarce1bcfe2015-01-02 12:34:35 +05302437 pr_debug("%s: No CPU initialized for driver %s\n", __func__,
2438 driver_data->name);
2439 goto err_if_unreg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440 }
2441
Jiri Slaby8f5bc2a2011-03-01 17:41:10 +01002442 register_hotcpu_notifier(&cpufreq_cpu_notifier);
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02002443 pr_debug("driver %s up and running\n", driver_data->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444
Rafael J. Wysockifdd320d2015-07-30 01:45:07 +02002445out:
2446 put_online_cpus();
2447 return ret;
2448
Kay Sievers8a25a2f2011-12-21 14:29:42 -08002449err_if_unreg:
2450 subsys_interface_unregister(&cpufreq_interface);
Lukasz Majewski6f19efc2013-12-20 15:24:49 +01002451err_boost_unreg:
Viresh Kumar44139ed2015-07-29 16:23:09 +05302452 remove_boost_sysfs_file();
Jiri Slaby8f5bc2a2011-03-01 17:41:10 +01002453err_null_driver:
Nathan Zimmer0d1857a2013-02-22 16:24:34 +00002454 write_lock_irqsave(&cpufreq_driver_lock, flags);
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +02002455 cpufreq_driver = NULL;
Nathan Zimmer0d1857a2013-02-22 16:24:34 +00002456 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
Rafael J. Wysockifdd320d2015-07-30 01:45:07 +02002457 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458}
2459EXPORT_SYMBOL_GPL(cpufreq_register_driver);
2460
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461/**
2462 * cpufreq_unregister_driver - unregister the current CPUFreq driver
2463 *
Viresh Kumarbb176f72013-06-19 14:19:33 +05302464 * Unregister the current CPUFreq driver. Only call this if you have
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 * the right to do so, i.e. if you have succeeded in initialising before!
2466 * Returns zero if successful, and -EINVAL if the cpufreq_driver is
2467 * currently not initialised.
2468 */
Linus Torvalds221dee22007-02-26 14:55:48 -08002469int cpufreq_unregister_driver(struct cpufreq_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002470{
2471 unsigned long flags;
2472
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +02002473 if (!cpufreq_driver || (driver != cpufreq_driver))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02002476 pr_debug("unregistering driver %s\n", driver->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477
Sebastian Andrzej Siewior454d3a22015-07-22 17:59:11 +02002478 /* Protect against concurrent cpu hotplug */
2479 get_online_cpus();
Kay Sievers8a25a2f2011-12-21 14:29:42 -08002480 subsys_interface_unregister(&cpufreq_interface);
Viresh Kumar44139ed2015-07-29 16:23:09 +05302481 remove_boost_sysfs_file();
Chandra Seetharaman65edc682006-06-27 02:54:08 -07002482 unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483
Nathan Zimmer0d1857a2013-02-22 16:24:34 +00002484 write_lock_irqsave(&cpufreq_driver_lock, flags);
Viresh Kumar6eed9402013-08-06 22:53:11 +05302485
Rafael J. Wysocki1c3d85d2013-04-29 00:08:16 +02002486 cpufreq_driver = NULL;
Viresh Kumar6eed9402013-08-06 22:53:11 +05302487
Nathan Zimmer0d1857a2013-02-22 16:24:34 +00002488 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
Sebastian Andrzej Siewior454d3a22015-07-22 17:59:11 +02002489 put_online_cpus();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490
2491 return 0;
2492}
2493EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08002494
Doug Anderson90de2a42014-12-23 22:09:48 -08002495/*
2496 * Stop cpufreq at shutdown to make sure it isn't holding any locks
2497 * or mutexes when secondary CPUs are halted.
2498 */
2499static struct syscore_ops cpufreq_syscore_ops = {
2500 .shutdown = cpufreq_suspend,
2501};
2502
Viresh Kumarc82bd442015-10-15 21:35:23 +05302503struct kobject *cpufreq_global_kobject;
2504EXPORT_SYMBOL(cpufreq_global_kobject);
2505
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08002506static int __init cpufreq_core_init(void)
2507{
Konrad Rzeszutek Wilka7b422c2012-03-13 19:18:39 -04002508 if (cpufreq_disabled())
2509 return -ENODEV;
2510
Viresh Kumar8eec1022015-10-15 21:35:22 +05302511 cpufreq_global_kobject = kobject_create_and_add("cpufreq", &cpu_subsys.dev_root->kobj);
Thomas Renninger8aa84ad2009-07-24 15:25:05 +02002512 BUG_ON(!cpufreq_global_kobject);
2513
Doug Anderson90de2a42014-12-23 22:09:48 -08002514 register_syscore_ops(&cpufreq_syscore_ops);
2515
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08002516 return 0;
2517}
Venkatesh Pallipadi5a01f2e2007-02-05 16:12:44 -08002518core_initcall(cpufreq_core_init);