cpufreq.c 62.7 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
/*
 *  linux/drivers/cpufreq/cpufreq.c
 *
 *  Copyright (C) 2001 Russell King
 *            (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
6
 *            (C) 2013 Viresh Kumar <viresh.kumar@linaro.org>
Linus Torvalds's avatar
Linus Torvalds committed
7
 *
8
 *  Oct 2005 - Ashok Raj <ashok.raj@intel.com>
9
 *	Added handling for CPU hotplug
10
11
 *  Feb 2006 - Jacob Shin <jacob.shin@amd.com>
 *	Fix handling for CPU hotplug -- affected CPUs
12
 *
Linus Torvalds's avatar
Linus Torvalds committed
13
14
15
16
17
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

Viresh Kumar's avatar
Viresh Kumar committed
18
19
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

20
#include <linux/cpu.h>
Linus Torvalds's avatar
Linus Torvalds committed
21
22
23
#include <linux/cpufreq.h>
#include <linux/delay.h>
#include <linux/device.h>
24
25
26
#include <linux/init.h>
#include <linux/kernel_stat.h>
#include <linux/module.h>
27
#include <linux/mutex.h>
28
#include <linux/slab.h>
29
#include <linux/suspend.h>
30
#include <linux/syscore_ops.h>
31
#include <linux/tick.h>
32
33
#include <trace/events/power.h>

34
static LIST_HEAD(cpufreq_policy_list);
35
36
37
38
39
40
41

static inline bool policy_is_inactive(struct cpufreq_policy *policy)
{
	return cpumask_empty(policy->cpus);
}

/* Macros to iterate over CPU policies */
42
43
44
#define for_each_suitable_policy(__policy, __active)			 \
	list_for_each_entry(__policy, &cpufreq_policy_list, policy_list) \
		if ((__active) == !policy_is_inactive(__policy))
45
46
47
48
49
50
51

#define for_each_active_policy(__policy)		\
	for_each_suitable_policy(__policy, true)
#define for_each_inactive_policy(__policy)		\
	for_each_suitable_policy(__policy, false)

#define for_each_policy(__policy)			\
52
53
	list_for_each_entry(__policy, &cpufreq_policy_list, policy_list)

54
55
56
57
58
/* Iterate over governors */
static LIST_HEAD(cpufreq_governor_list);
#define for_each_governor(__governor)				\
	list_for_each_entry(__governor, &cpufreq_governor_list, governor_list)

Linus Torvalds's avatar
Linus Torvalds committed
59
/**
Dave Jones's avatar
Dave Jones committed
60
 * The "cpufreq driver" - the arch- or hardware-dependent low
Linus Torvalds's avatar
Linus Torvalds committed
61
62
63
 * level driver of CPUFreq support, and its spinlock. This lock
 * also protects the cpufreq_cpu_data array.
 */
64
static struct cpufreq_driver *cpufreq_driver;
65
static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
66
67
static DEFINE_RWLOCK(cpufreq_driver_lock);

68
69
/* Flag to suspend/resume CPUFreq governors */
static bool cpufreq_suspended;
Linus Torvalds's avatar
Linus Torvalds committed
70

71
72
73
74
75
static inline bool has_target(void)
{
	return cpufreq_driver->target_index || cpufreq_driver->target;
}

Linus Torvalds's avatar
Linus Torvalds committed
76
/* internal prototypes */
77
static int cpufreq_governor(struct cpufreq_policy *policy, unsigned int event);
78
static unsigned int __cpufreq_get(struct cpufreq_policy *policy);
79
static int cpufreq_start_governor(struct cpufreq_policy *policy);
Linus Torvalds's avatar
Linus Torvalds committed
80
81

/**
82
83
 * Two notifier lists: the "policy" list is involved in the
 * validation process for a new CPU frequency policy; the
Linus Torvalds's avatar
Linus Torvalds committed
84
85
86
87
 * "transition" list for kernel code that needs to handle
 * changes to devices when the CPU clock speed changes.
 * The mutex locks both lists.
 */
88
static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
89
static struct srcu_notifier_head cpufreq_transition_notifier_list;
Linus Torvalds's avatar
Linus Torvalds committed
90

91
static bool init_cpufreq_transition_notifier_list_called;
92
93
94
static int __init init_cpufreq_transition_notifier_list(void)
{
	srcu_init_notifier_head(&cpufreq_transition_notifier_list);
95
	init_cpufreq_transition_notifier_list_called = true;
96
97
	return 0;
}
98
pure_initcall(init_cpufreq_transition_notifier_list);
Linus Torvalds's avatar
Linus Torvalds committed
99

100
static int off __read_mostly;
101
static int cpufreq_disabled(void)
102
103
104
105
106
107
108
{
	return off;
}
void disable_cpufreq(void)
{
	off = 1;
}
109
static DEFINE_MUTEX(cpufreq_governor_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
110

111
112
bool have_governor_per_policy(void)
{
113
	return !!(cpufreq_driver->flags & CPUFREQ_HAVE_GOVERNOR_PER_POLICY);
114
}
115
EXPORT_SYMBOL_GPL(have_governor_per_policy);
116

117
118
119
120
121
122
123
124
125
struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy)
{
	if (have_governor_per_policy())
		return &policy->kobj;
	else
		return cpufreq_global_kobject;
}
EXPORT_SYMBOL_GPL(get_governor_parent_kobj);

126
127
128
129
130
131
132
133
134
struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu)
{
	struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);

	return policy && !policy_is_inactive(policy) ?
		policy->freq_table : NULL;
}
EXPORT_SYMBOL_GPL(cpufreq_frequency_get_table);

135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall)
{
	u64 idle_time;
	u64 cur_wall_time;
	u64 busy_time;

	cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());

	busy_time = kcpustat_cpu(cpu).cpustat[CPUTIME_USER];
	busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM];
	busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_IRQ];
	busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SOFTIRQ];
	busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_STEAL];
	busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_NICE];

	idle_time = cur_wall_time - busy_time;
	if (wall)
		*wall = cputime_to_usecs(cur_wall_time);

	return cputime_to_usecs(idle_time);
}

u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy)
{
	u64 idle_time = get_cpu_idle_time_us(cpu, io_busy ? wall : NULL);

	if (idle_time == -1ULL)
		return get_cpu_idle_time_jiffy(cpu, wall);
	else if (!io_busy)
		idle_time += get_cpu_iowait_time_us(cpu, wall);

	return idle_time;
}
EXPORT_SYMBOL_GPL(get_cpu_idle_time);

170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
/*
 * This is a generic cpufreq init() routine which can be used by cpufreq
 * drivers of SMP systems. It will do following:
 * - validate & show freq table passed
 * - set policies transition latency
 * - policy->cpus with all possible CPUs
 */
int cpufreq_generic_init(struct cpufreq_policy *policy,
		struct cpufreq_frequency_table *table,
		unsigned int transition_latency)
{
	int ret;

	ret = cpufreq_table_validate_and_show(policy, table);
	if (ret) {
		pr_err("%s: invalid frequency table: %d\n", __func__, ret);
		return ret;
	}

	policy->cpuinfo.transition_latency = transition_latency;

	/*
192
	 * The driver only supports the SMP configuration where all processors
193
194
195
196
197
198
199
200
	 * share the clock and voltage and clock.
	 */
	cpumask_setall(policy->cpus);

	return 0;
}
EXPORT_SYMBOL_GPL(cpufreq_generic_init);

201
struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu)
202
203
204
{
	struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);

205
206
	return policy && cpumask_test_cpu(cpu, policy->cpus) ? policy : NULL;
}
207
EXPORT_SYMBOL_GPL(cpufreq_cpu_get_raw);
208
209
210
211
212

unsigned int cpufreq_generic_get(unsigned int cpu)
{
	struct cpufreq_policy *policy = cpufreq_cpu_get_raw(cpu);

213
	if (!policy || IS_ERR(policy->clk)) {
214
215
		pr_err("%s: No %s associated to cpu: %d\n",
		       __func__, policy ? "clk" : "policy", cpu);
216
217
218
219
220
221
222
		return 0;
	}

	return clk_get_rate(policy->clk) / 1000;
}
EXPORT_SYMBOL_GPL(cpufreq_generic_get);

223
224
225
226
227
228
229
230
231
232
233
234
235
/**
 * cpufreq_cpu_get: returns policy for a cpu and marks it busy.
 *
 * @cpu: cpu to find policy for.
 *
 * This returns policy for 'cpu', returns NULL if it doesn't exist.
 * It also increments the kobject reference count to mark it busy and so would
 * require a corresponding call to cpufreq_cpu_put() to decrement it back.
 * If corresponding call cpufreq_cpu_put() isn't made, the policy wouldn't be
 * freed as that depends on the kobj count.
 *
 * Return: A valid policy on success, otherwise NULL on failure.
 */
236
struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
Linus Torvalds's avatar
Linus Torvalds committed
237
{
238
	struct cpufreq_policy *policy = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
239
240
	unsigned long flags;

241
	if (WARN_ON(cpu >= nr_cpu_ids))
242
243
		return NULL;

Linus Torvalds's avatar
Linus Torvalds committed
244
	/* get the cpufreq driver */
245
	read_lock_irqsave(&cpufreq_driver_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
246

247
248
	if (cpufreq_driver) {
		/* get the CPU */
249
		policy = cpufreq_cpu_get_raw(cpu);
250
251
252
		if (policy)
			kobject_get(&policy->kobj);
	}
Linus Torvalds's avatar
Linus Torvalds committed
253

254
	read_unlock_irqrestore(&cpufreq_driver_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
255

256
	return policy;
257
}
Linus Torvalds's avatar
Linus Torvalds committed
258
259
EXPORT_SYMBOL_GPL(cpufreq_cpu_get);

260
261
262
263
264
265
266
267
/**
 * cpufreq_cpu_put: Decrements the usage count of a policy
 *
 * @policy: policy earlier returned by cpufreq_cpu_get().
 *
 * This decrements the kobject reference count incremented earlier by calling
 * cpufreq_cpu_get().
 */
268
void cpufreq_cpu_put(struct cpufreq_policy *policy)
Linus Torvalds's avatar
Linus Torvalds committed
269
{
270
	kobject_put(&policy->kobj);
Linus Torvalds's avatar
Linus Torvalds committed
271
272
273
274
275
276
277
278
279
280
281
282
}
EXPORT_SYMBOL_GPL(cpufreq_cpu_put);

/*********************************************************************
 *            EXTERNALLY AFFECTING FREQUENCY CHANGES                 *
 *********************************************************************/

/**
 * adjust_jiffies - adjust the system "loops_per_jiffy"
 *
 * This function alters the system "loops_per_jiffy" for the clock
 * speed change. Note that loops_per_jiffy cannot be updated on SMP
283
 * systems as each CPU might be scaled differently. So, use the arch
Linus Torvalds's avatar
Linus Torvalds committed
284
285
 * per-CPU loops_per_jiffy value wherever possible.
 */
286
static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
Linus Torvalds's avatar
Linus Torvalds committed
287
{
288
289
290
291
#ifndef CONFIG_SMP
	static unsigned long l_p_j_ref;
	static unsigned int l_p_j_ref_freq;

Linus Torvalds's avatar
Linus Torvalds committed
292
293
294
295
296
297
	if (ci->flags & CPUFREQ_CONST_LOOPS)
		return;

	if (!l_p_j_ref_freq) {
		l_p_j_ref = loops_per_jiffy;
		l_p_j_ref_freq = ci->old;
298
299
		pr_debug("saving %lu as reference value for loops_per_jiffy; freq is %u kHz\n",
			 l_p_j_ref, l_p_j_ref_freq);
Linus Torvalds's avatar
Linus Torvalds committed
300
	}
301
	if (val == CPUFREQ_POSTCHANGE && ci->old != ci->new) {
302
303
		loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
								ci->new);
304
305
		pr_debug("scaling loops_per_jiffy to %lu for frequency %u kHz\n",
			 loops_per_jiffy, ci->new);
Linus Torvalds's avatar
Linus Torvalds committed
306
307
	}
#endif
308
}
Linus Torvalds's avatar
Linus Torvalds committed
309

310
static void __cpufreq_notify_transition(struct cpufreq_policy *policy,
311
		struct cpufreq_freqs *freqs, unsigned int state)
Linus Torvalds's avatar
Linus Torvalds committed
312
313
314
{
	BUG_ON(irqs_disabled());

315
316
317
	if (cpufreq_disabled())
		return;

318
	freqs->flags = cpufreq_driver->flags;
319
	pr_debug("notification %u of frequency transition to %u kHz\n",
320
		 state, freqs->new);
Linus Torvalds's avatar
Linus Torvalds committed
321
322

	switch (state) {
323

Linus Torvalds's avatar
Linus Torvalds committed
324
	case CPUFREQ_PRECHANGE:
325
		/* detect if the driver reported a value as "old frequency"
326
327
		 * which is not equal to what the cpufreq core thinks is
		 * "old frequency".
Linus Torvalds's avatar
Linus Torvalds committed
328
		 */
329
		if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
330
331
			if ((policy) && (policy->cpu == freqs->cpu) &&
			    (policy->cur) && (policy->cur != freqs->old)) {
332
333
				pr_debug("Warning: CPU frequency is %u, cpufreq assumed %u kHz\n",
					 freqs->old, policy->cur);
334
				freqs->old = policy->cur;
Linus Torvalds's avatar
Linus Torvalds committed
335
336
			}
		}
337
		srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
338
				CPUFREQ_PRECHANGE, freqs);
Linus Torvalds's avatar
Linus Torvalds committed
339
340
		adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
		break;
341

Linus Torvalds's avatar
Linus Torvalds committed
342
343
	case CPUFREQ_POSTCHANGE:
		adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
344
345
		pr_debug("FREQ: %lu - CPU: %lu\n",
			 (unsigned long)freqs->new, (unsigned long)freqs->cpu);
346
		trace_cpu_frequency(freqs->new, freqs->cpu);
347
		srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
348
				CPUFREQ_POSTCHANGE, freqs);
349
350
		if (likely(policy) && likely(policy->cpu == freqs->cpu))
			policy->cur = freqs->new;
Linus Torvalds's avatar
Linus Torvalds committed
351
352
353
		break;
	}
}
354

355
356
357
358
359
360
361
362
/**
 * cpufreq_notify_transition - call notifier chain and adjust_jiffies
 * on frequency transition.
 *
 * This function calls the transition notifiers and the "adjust_jiffies"
 * function. It is called twice on all CPU frequency changes that have
 * external effects.
 */
363
static void cpufreq_notify_transition(struct cpufreq_policy *policy,
364
365
366
367
368
		struct cpufreq_freqs *freqs, unsigned int state)
{
	for_each_cpu(freqs->cpu, policy->cpus)
		__cpufreq_notify_transition(policy, freqs, state);
}
Linus Torvalds's avatar
Linus Torvalds committed
369

370
/* Do post notifications when there are chances that transition has failed */
371
static void cpufreq_notify_post_transition(struct cpufreq_policy *policy,
372
373
374
375
376
377
378
379
380
381
382
		struct cpufreq_freqs *freqs, int transition_failed)
{
	cpufreq_notify_transition(policy, freqs, CPUFREQ_POSTCHANGE);
	if (!transition_failed)
		return;

	swap(freqs->old, freqs->new);
	cpufreq_notify_transition(policy, freqs, CPUFREQ_PRECHANGE);
	cpufreq_notify_transition(policy, freqs, CPUFREQ_POSTCHANGE);
}

383
384
385
void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
		struct cpufreq_freqs *freqs)
{
386
387
388
389
390
391
392
393
394
395
396
397

	/*
	 * Catch double invocations of _begin() which lead to self-deadlock.
	 * ASYNC_NOTIFICATION drivers are left out because the cpufreq core
	 * doesn't invoke _begin() on their behalf, and hence the chances of
	 * double invocations are very low. Moreover, there are scenarios
	 * where these checks can emit false-positive warnings in these
	 * drivers; so we avoid that by skipping them altogether.
	 */
	WARN_ON(!(cpufreq_driver->flags & CPUFREQ_ASYNC_NOTIFICATION)
				&& current == policy->transition_task);

398
399
400
401
402
403
404
405
406
407
408
wait:
	wait_event(policy->transition_wait, !policy->transition_ongoing);

	spin_lock(&policy->transition_lock);

	if (unlikely(policy->transition_ongoing)) {
		spin_unlock(&policy->transition_lock);
		goto wait;
	}

	policy->transition_ongoing = true;
409
	policy->transition_task = current;
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425

	spin_unlock(&policy->transition_lock);

	cpufreq_notify_transition(policy, freqs, CPUFREQ_PRECHANGE);
}
EXPORT_SYMBOL_GPL(cpufreq_freq_transition_begin);

void cpufreq_freq_transition_end(struct cpufreq_policy *policy,
		struct cpufreq_freqs *freqs, int transition_failed)
{
	if (unlikely(WARN_ON(!policy->transition_ongoing)))
		return;

	cpufreq_notify_post_transition(policy, freqs, transition_failed);

	policy->transition_ongoing = false;
426
	policy->transition_task = NULL;
427
428
429
430
431

	wake_up(&policy->transition_wait);
}
EXPORT_SYMBOL_GPL(cpufreq_freq_transition_end);

Linus Torvalds's avatar
Linus Torvalds committed
432
433
434
435

/*********************************************************************
 *                          SYSFS INTERFACE                          *
 *********************************************************************/
436
static ssize_t show_boost(struct kobject *kobj,
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
				 struct attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", cpufreq_driver->boost_enabled);
}

static ssize_t store_boost(struct kobject *kobj, struct attribute *attr,
				  const char *buf, size_t count)
{
	int ret, enable;

	ret = sscanf(buf, "%d", &enable);
	if (ret != 1 || enable < 0 || enable > 1)
		return -EINVAL;

	if (cpufreq_boost_trigger_state(enable)) {
452
453
		pr_err("%s: Cannot %s BOOST!\n",
		       __func__, enable ? "enable" : "disable");
454
455
456
		return -EINVAL;
	}

457
458
	pr_debug("%s: cpufreq BOOST %s\n",
		 __func__, enable ? "enabled" : "disabled");
459
460
461
462

	return count;
}
define_one_global_rw(boost);
Linus Torvalds's avatar
Linus Torvalds committed
463

464
static struct cpufreq_governor *find_governor(const char *str_governor)
465
466
467
{
	struct cpufreq_governor *t;

468
	for_each_governor(t)
469
		if (!strncasecmp(str_governor, t->name, CPUFREQ_NAME_LEN))
470
471
472
473
474
			return t;

	return NULL;
}

Linus Torvalds's avatar
Linus Torvalds committed
475
476
477
/**
 * cpufreq_parse_governor - parse a governor string
 */
Dave Jones's avatar
Dave Jones committed
478
static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
Linus Torvalds's avatar
Linus Torvalds committed
479
480
				struct cpufreq_governor **governor)
{
481
	int err = -EINVAL;
482
483

	if (cpufreq_driver->setpolicy) {
484
		if (!strncasecmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
Linus Torvalds's avatar
Linus Torvalds committed
485
			*policy = CPUFREQ_POLICY_PERFORMANCE;
486
			err = 0;
487
		} else if (!strncasecmp(str_governor, "powersave",
488
						CPUFREQ_NAME_LEN)) {
Linus Torvalds's avatar
Linus Torvalds committed
489
			*policy = CPUFREQ_POLICY_POWERSAVE;
490
			err = 0;
Linus Torvalds's avatar
Linus Torvalds committed
491
		}
492
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
493
		struct cpufreq_governor *t;
494

495
		mutex_lock(&cpufreq_governor_mutex);
496

497
		t = find_governor(str_governor);
498

499
		if (t == NULL) {
500
			int ret;
501

502
503
504
			mutex_unlock(&cpufreq_governor_mutex);
			ret = request_module("cpufreq_%s", str_governor);
			mutex_lock(&cpufreq_governor_mutex);
505

506
			if (ret == 0)
507
				t = find_governor(str_governor);
508
509
		}

510
511
512
		if (t != NULL) {
			*governor = t;
			err = 0;
Linus Torvalds's avatar
Linus Torvalds committed
513
		}
514

515
		mutex_unlock(&cpufreq_governor_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
516
	}
517
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
518
519
520
}

/**
521
522
 * cpufreq_per_cpu_attr_read() / show_##file_name() -
 * print out cpufreq information
Linus Torvalds's avatar
Linus Torvalds committed
523
524
525
526
527
 *
 * Write out information from cpufreq_driver->policy[cpu]; object must be
 * "unsigned int".
 */

528
529
#define show_one(file_name, object)			\
static ssize_t show_##file_name				\
Dave Jones's avatar
Dave Jones committed
530
(struct cpufreq_policy *policy, char *buf)		\
531
{							\
532
	return sprintf(buf, "%u\n", policy->object);	\
Linus Torvalds's avatar
Linus Torvalds committed
533
534
535
536
}

show_one(cpuinfo_min_freq, cpuinfo.min_freq);
show_one(cpuinfo_max_freq, cpuinfo.max_freq);
537
show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
Linus Torvalds's avatar
Linus Torvalds committed
538
539
show_one(scaling_min_freq, min);
show_one(scaling_max_freq, max);
540

541
static ssize_t show_scaling_cur_freq(struct cpufreq_policy *policy, char *buf)
542
543
544
545
546
547
548
549
550
{
	ssize_t ret;

	if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get)
		ret = sprintf(buf, "%u\n", cpufreq_driver->get(policy->cpu));
	else
		ret = sprintf(buf, "%u\n", policy->cur);
	return ret;
}
Linus Torvalds's avatar
Linus Torvalds committed
551

552
static int cpufreq_set_policy(struct cpufreq_policy *policy,
553
				struct cpufreq_policy *new_policy);
554

Linus Torvalds's avatar
Linus Torvalds committed
555
556
557
558
559
/**
 * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
 */
#define store_one(file_name, object)			\
static ssize_t store_##file_name					\
Dave Jones's avatar
Dave Jones committed
560
(struct cpufreq_policy *policy, const char *buf, size_t count)		\
Linus Torvalds's avatar
Linus Torvalds committed
561
{									\
562
	int ret, temp;							\
Linus Torvalds's avatar
Linus Torvalds committed
563
564
	struct cpufreq_policy new_policy;				\
									\
565
	memcpy(&new_policy, policy, sizeof(*policy));			\
Linus Torvalds's avatar
Linus Torvalds committed
566
									\
567
	ret = sscanf(buf, "%u", &new_policy.object);			\
Linus Torvalds's avatar
Linus Torvalds committed
568
569
570
	if (ret != 1)							\
		return -EINVAL;						\
									\
571
	temp = new_policy.object;					\
572
	ret = cpufreq_set_policy(policy, &new_policy);		\
573
574
	if (!ret)							\
		policy->user_policy.object = temp;			\
Linus Torvalds's avatar
Linus Torvalds committed
575
576
577
578
									\
	return ret ? ret : count;					\
}

579
580
store_one(scaling_min_freq, min);
store_one(scaling_max_freq, max);
Linus Torvalds's avatar
Linus Torvalds committed
581
582
583
584

/**
 * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
 */
Dave Jones's avatar
Dave Jones committed
585
586
static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
					char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
587
{
588
	unsigned int cur_freq = __cpufreq_get(policy);
Linus Torvalds's avatar
Linus Torvalds committed
589
590
591
592
593
594
595
596
	if (!cur_freq)
		return sprintf(buf, "<unknown>");
	return sprintf(buf, "%u\n", cur_freq);
}

/**
 * show_scaling_governor - show the current policy for the specified CPU
 */
Dave Jones's avatar
Dave Jones committed
597
static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
598
{
599
	if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
Linus Torvalds's avatar
Linus Torvalds committed
600
601
602
603
		return sprintf(buf, "powersave\n");
	else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
		return sprintf(buf, "performance\n");
	else if (policy->governor)
604
		return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n",
605
				policy->governor->name);
Linus Torvalds's avatar
Linus Torvalds committed
606
607
608
609
610
611
	return -EINVAL;
}

/**
 * store_scaling_governor - store policy for the specified CPU
 */
Dave Jones's avatar
Dave Jones committed
612
613
static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
					const char *buf, size_t count)
Linus Torvalds's avatar
Linus Torvalds committed
614
{
615
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
616
617
618
	char	str_governor[16];
	struct cpufreq_policy new_policy;

619
	memcpy(&new_policy, policy, sizeof(*policy));
Linus Torvalds's avatar
Linus Torvalds committed
620

621
	ret = sscanf(buf, "%15s", str_governor);
Linus Torvalds's avatar
Linus Torvalds committed
622
623
624
	if (ret != 1)
		return -EINVAL;

625
626
	if (cpufreq_parse_governor(str_governor, &new_policy.policy,
						&new_policy.governor))
Linus Torvalds's avatar
Linus Torvalds committed
627
628
		return -EINVAL;

629
	ret = cpufreq_set_policy(policy, &new_policy);
630
	return ret ? ret : count;
Linus Torvalds's avatar
Linus Torvalds committed
631
632
633
634
635
}

/**
 * show_scaling_driver - show the cpufreq driver currently loaded
 */
Dave Jones's avatar
Dave Jones committed
636
static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
637
{
638
	return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n", cpufreq_driver->name);
Linus Torvalds's avatar
Linus Torvalds committed
639
640
641
642
643
}

/**
 * show_scaling_available_governors - show the available CPUfreq governors
 */
Dave Jones's avatar
Dave Jones committed
644
645
static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
						char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
646
647
648
649
{
	ssize_t i = 0;
	struct cpufreq_governor *t;

650
	if (!has_target()) {
Linus Torvalds's avatar
Linus Torvalds committed
651
652
653
654
		i += sprintf(buf, "performance powersave");
		goto out;
	}

655
	for_each_governor(t) {
656
657
		if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
		    - (CPUFREQ_NAME_LEN + 2)))
Linus Torvalds's avatar
Linus Torvalds committed
658
			goto out;
659
		i += scnprintf(&buf[i], CPUFREQ_NAME_PLEN, "%s ", t->name);
Linus Torvalds's avatar
Linus Torvalds committed
660
	}
661
out:
Linus Torvalds's avatar
Linus Torvalds committed
662
663
664
	i += sprintf(&buf[i], "\n");
	return i;
}
665

666
ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
667
668
669
670
{
	ssize_t i = 0;
	unsigned int cpu;

671
	for_each_cpu(cpu, mask) {
Linus Torvalds's avatar
Linus Torvalds committed
672
673
674
675
		if (i)
			i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
		i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
		if (i >= (PAGE_SIZE - 5))
676
			break;
Linus Torvalds's avatar
Linus Torvalds committed
677
678
679
680
	}
	i += sprintf(&buf[i], "\n");
	return i;
}
681
EXPORT_SYMBOL_GPL(cpufreq_show_cpus);
Linus Torvalds's avatar
Linus Torvalds committed
682

683
684
685
686
687
688
/**
 * show_related_cpus - show the CPUs affected by each transition even if
 * hw coordination is in use
 */
static ssize_t show_related_cpus(struct cpufreq_policy *policy, char *buf)
{
689
	return cpufreq_show_cpus(policy->related_cpus, buf);
690
691
692
693
694
695
696
}

/**
 * show_affected_cpus - show the CPUs affected by each transition
 */
static ssize_t show_affected_cpus(struct cpufreq_policy *policy, char *buf)
{
697
	return cpufreq_show_cpus(policy->cpus, buf);
698
699
}

700
static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
Dave Jones's avatar
Dave Jones committed
701
					const char *buf, size_t count)
702
703
704
705
{
	unsigned int freq = 0;
	unsigned int ret;

706
	if (!policy->governor || !policy->governor->store_setspeed)
707
708
709
710
711
712
713
714
715
716
717
718
719
		return -EINVAL;

	ret = sscanf(buf, "%u", &freq);
	if (ret != 1)
		return -EINVAL;

	policy->governor->store_setspeed(policy, freq);

	return count;
}

static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
{
720
	if (!policy->governor || !policy->governor->show_setspeed)
721
722
723
724
		return sprintf(buf, "<unsupported>\n");

	return policy->governor->show_setspeed(policy, buf);
}
Linus Torvalds's avatar
Linus Torvalds committed
725

726
/**
727
 * show_bios_limit - show the current cpufreq HW/BIOS limitation
728
729
730
731
732
 */
static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
{
	unsigned int limit;
	int ret;
733
734
	if (cpufreq_driver->bios_limit) {
		ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
735
736
737
738
739
740
		if (!ret)
			return sprintf(buf, "%u\n", limit);
	}
	return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
}

741
742
743
744
745
746
747
748
749
750
751
752
753
754
cpufreq_freq_attr_ro_perm(cpuinfo_cur_freq, 0400);
cpufreq_freq_attr_ro(cpuinfo_min_freq);
cpufreq_freq_attr_ro(cpuinfo_max_freq);
cpufreq_freq_attr_ro(cpuinfo_transition_latency);
cpufreq_freq_attr_ro(scaling_available_governors);
cpufreq_freq_attr_ro(scaling_driver);
cpufreq_freq_attr_ro(scaling_cur_freq);
cpufreq_freq_attr_ro(bios_limit);
cpufreq_freq_attr_ro(related_cpus);
cpufreq_freq_attr_ro(affected_cpus);
cpufreq_freq_attr_rw(scaling_min_freq);
cpufreq_freq_attr_rw(scaling_max_freq);
cpufreq_freq_attr_rw(scaling_governor);
cpufreq_freq_attr_rw(scaling_setspeed);
Linus Torvalds's avatar
Linus Torvalds committed
755

Dave Jones's avatar
Dave Jones committed
756
static struct attribute *default_attrs[] = {
Linus Torvalds's avatar
Linus Torvalds committed
757
758
	&cpuinfo_min_freq.attr,
	&cpuinfo_max_freq.attr,
759
	&cpuinfo_transition_latency.attr,
Linus Torvalds's avatar
Linus Torvalds committed
760
761
762
	&scaling_min_freq.attr,
	&scaling_max_freq.attr,
	&affected_cpus.attr,
763
	&related_cpus.attr,
Linus Torvalds's avatar
Linus Torvalds committed
764
765
766
	&scaling_governor.attr,
	&scaling_driver.attr,
	&scaling_available_governors.attr,
767
	&scaling_setspeed.attr,
Linus Torvalds's avatar
Linus Torvalds committed
768
769
770
	NULL
};

771
772
#define to_policy(k) container_of(k, struct cpufreq_policy, kobj)
#define to_attr(a) container_of(a, struct freq_attr, attr)
Linus Torvalds's avatar
Linus Torvalds committed
773

774
static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
775
{
Dave Jones's avatar
Dave Jones committed
776
777
	struct cpufreq_policy *policy = to_policy(kobj);
	struct freq_attr *fattr = to_attr(attr);
778
	ssize_t ret;
779

780
	down_read(&policy->rwsem);
781
	ret = fattr->show(policy, buf);
782
	up_read(&policy->rwsem);
783

Linus Torvalds's avatar
Linus Torvalds committed
784
785
786
	return ret;
}

Dave Jones's avatar
Dave Jones committed
787
788
static ssize_t store(struct kobject *kobj, struct attribute *attr,
		     const char *buf, size_t count)
Linus Torvalds's avatar
Linus Torvalds committed
789
{
Dave Jones's avatar
Dave Jones committed
790
791
	struct cpufreq_policy *policy = to_policy(kobj);
	struct freq_attr *fattr = to_attr(attr);
792
	ssize_t ret = -EINVAL;
793

794
795
	get_online_cpus();

796
797
	if (cpu_online(policy->cpu)) {
		down_write(&policy->rwsem);
798
		ret = fattr->store(policy, buf, count);
799
800
		up_write(&policy->rwsem);
	}
801

802
803
	put_online_cpus();

Linus Torvalds's avatar
Linus Torvalds committed
804
805
806
	return ret;
}

Dave Jones's avatar
Dave Jones committed
807
static void cpufreq_sysfs_release(struct kobject *kobj)
Linus Torvalds's avatar
Linus Torvalds committed
808
{
Dave Jones's avatar
Dave Jones committed
809
	struct cpufreq_policy *policy = to_policy(kobj);
810
	pr_debug("last reference is dropped\n");
Linus Torvalds's avatar
Linus Torvalds committed
811
812
813
	complete(&policy->kobj_unregister);
}

814
static const struct sysfs_ops sysfs_ops = {
Linus Torvalds's avatar
Linus Torvalds committed
815
816
817
818
819
820
821
822
823
824
	.show	= show,
	.store	= store,
};

static struct kobj_type ktype_cpufreq = {
	.sysfs_ops	= &sysfs_ops,
	.default_attrs	= default_attrs,
	.release	= cpufreq_sysfs_release,
};

825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
static int add_cpu_dev_symlink(struct cpufreq_policy *policy, int cpu)
{
	struct device *cpu_dev;

	pr_debug("%s: Adding symlink for CPU: %u\n", __func__, cpu);

	if (!policy)
		return 0;

	cpu_dev = get_cpu_device(cpu);
	if (WARN_ON(!cpu_dev))
		return 0;

	return sysfs_create_link(&cpu_dev->kobj, &policy->kobj, "cpufreq");
}

static void remove_cpu_dev_symlink(struct cpufreq_policy *policy, int cpu)
{
	struct device *cpu_dev;

	pr_debug("%s: Removing symlink for CPU: %u\n", __func__, cpu);

	cpu_dev = get_cpu_device(cpu);
	if (WARN_ON(!cpu_dev))
		return;

	sysfs_remove_link(&cpu_dev->kobj, "cpufreq");
}

/* Add/remove symlinks for all related CPUs */
855
static int cpufreq_add_dev_symlink(struct cpufreq_policy *policy)
856
857
858
859
{
	unsigned int j;
	int ret = 0;

860
	/* Some related CPUs might not be present (physically hotplugged) */
861
	for_each_cpu(j, policy->real_cpus) {
862
		ret = add_cpu_dev_symlink(policy, j);
863
864
		if (ret)
			break;
865
	}
866

867
868
869
	return ret;
}

870
871
872
873
874
static void cpufreq_remove_dev_symlink(struct cpufreq_policy *policy)
{
	unsigned int j;

	/* Some related CPUs might not be present (physically hotplugged) */
875
	for_each_cpu(j, policy->real_cpus)
876
877
878
		remove_cpu_dev_symlink(policy, j);
}

879
static int cpufreq_add_dev_interface(struct cpufreq_policy *policy)
880
881
882
883
884
{
	struct freq_attr **drv_attr;
	int ret = 0;

	/* set up files for this cpu device */
885
	drv_attr = cpufreq_driver->attr;
886
	while (drv_attr && *drv_attr) {
887
888
		ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
		if (ret)
889
			return ret;
890
891
		drv_attr++;
	}
892
	if (cpufreq_driver->get) {
893
894
		ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
		if (ret)
895
			return ret;
896
	}
897
898
899

	ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
	if (ret)
900
		return ret;
901

902
	if (cpufreq_driver->bios_limit) {
903
904
		ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
		if (ret)
905
			return ret;
906
	}
907

908
	return cpufreq_add_dev_symlink(policy);
909
910
}

911
912
913
914
915
__weak struct cpufreq_governor *cpufreq_default_governor(void)
{
	return NULL;
}

916
static int cpufreq_init_policy(struct cpufreq_policy *policy)
917
{
918
	struct cpufreq_governor *gov = NULL;
919
920
	struct cpufreq_policy new_policy;

921
	memcpy(&new_policy, policy, sizeof(*policy));
922

923
	/* Update governor of new_policy to the governor used before hotplug */
924
	gov = find_governor(policy->last_governor);
925
	if (gov) {
926
927
		pr_debug("Restoring governor %s for cpu %d\n",
				policy->governor->name, policy->cpu);
928
929
930
931
932
	} else {
		gov = cpufreq_default_governor();
		if (!gov)
			return -ENODATA;
	}
933
934
935

	new_policy.governor = gov;

936
937
938
939
940
941
942
943
	/* Use the default policy if there is no last_policy. */
	if (cpufreq_driver->setpolicy) {
		if (policy->last_policy)
			new_policy.policy = policy->last_policy;
		else
			cpufreq_parse_governor(gov->name, &new_policy.policy,
					       NULL);
	}
944
	/* set default policy */
945
	return cpufreq_set_policy(policy, &new_policy);
946
947
}

948
static int cpufreq_add_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
949
{
950
	int ret = 0;
951

952
953
954
955
	/* Has this CPU been taken care of already? */
	if (cpumask_test_cpu(cpu, policy->cpus))
		return 0;

956
	down_write(&policy->rwsem);
957
	if (has_target()) {
958
		ret = cpufreq_governor(policy, CPUFREQ_GOV_STOP);
959
960
		if (ret) {
			pr_err("%s: Failed to stop governor\n", __func__);
961
			goto unlock;
962
963
		}
	}
964
965

	cpumask_set_cpu(cpu, policy->cpus);
Viresh Kumar's avatar
Viresh Kumar committed
966

967
	if (has_target()) {
968
		ret = cpufreq_start_governor(policy);
969
		if (ret)
970
			pr_err("%s: Failed to start governor\n", __func__);
971
	}
972

973
974
975
unlock:
	up_write(&policy->rwsem);
	return ret;
976
}
Linus Torvalds's avatar
Linus Torvalds committed
977

978
979
980
981
982
983
984
static void handle_update(struct work_struct *work)
{
	struct cpufreq_policy *policy =
		container_of(work, struct cpufreq_policy, update);
	unsigned int cpu = policy->cpu;
	pr_debug("handle_update for cpu %u called\n", cpu);
	cpufreq_update_policy(cpu);
985
}
Linus Torvalds's avatar
Linus Torvalds committed
986

987
static struct cpufreq_policy *cpufreq_policy_alloc(unsigned int cpu)
988
{
989
	struct device *dev = get_cpu_device(cpu);
990
	struct cpufreq_policy *policy;
991
	int ret;
992

993
994
995
	if (WARN_ON(!dev))
		return NULL;

996
997
998
999
1000
	policy = kzalloc(sizeof(*policy), GFP_KERNEL);
	if (!policy)
		return NULL;

	if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))