cpufreq.c 64.6 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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

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

static bool suitable_policy(struct cpufreq_policy *policy, bool active)
{
	return active == !policy_is_inactive(policy);
}

/* Finds Next Acive/Inactive policy */
static struct cpufreq_policy *next_policy(struct cpufreq_policy *policy,
					  bool active)
{
	do {
		policy = list_next_entry(policy, policy_list);

		/* No more policies in the list */
		if (&policy->policy_list == &cpufreq_policy_list)
			return NULL;
	} while (!suitable_policy(policy, active));

	return policy;
}

static struct cpufreq_policy *first_policy(bool active)
{
	struct cpufreq_policy *policy;

	/* No policies in the list */
	if (list_empty(&cpufreq_policy_list))
		return NULL;

	policy = list_first_entry(&cpufreq_policy_list, typeof(*policy),
				  policy_list);

	if (!suitable_policy(policy, active))
		policy = next_policy(policy, active);

	return policy;
}

/* Macros to iterate over CPU policies */
#define for_each_suitable_policy(__policy, __active)	\
	for (__policy = first_policy(__active);		\
	     __policy;					\
	     __policy = next_policy(__policy, __active))

#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)			\
90
91
	list_for_each_entry(__policy, &cpufreq_policy_list, policy_list)

92
93
94
95
96
/* 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
97
/**
Dave Jones's avatar
Dave Jones committed
98
 * The "cpufreq driver" - the arch- or hardware-dependent low
Linus Torvalds's avatar
Linus Torvalds committed
99
100
101
 * level driver of CPUFreq support, and its spinlock. This lock
 * also protects the cpufreq_cpu_data array.
 */
102
static struct cpufreq_driver *cpufreq_driver;
103
static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
104
static DEFINE_RWLOCK(cpufreq_driver_lock);
105
DEFINE_MUTEX(cpufreq_governor_lock);
106

107
108
/* Flag to suspend/resume CPUFreq governors */
static bool cpufreq_suspended;
Linus Torvalds's avatar
Linus Torvalds committed
109

110
111
112
113
114
static inline bool has_target(void)
{
	return cpufreq_driver->target_index || cpufreq_driver->target;
}

Linus Torvalds's avatar
Linus Torvalds committed
115
/* internal prototypes */
116
117
static int __cpufreq_governor(struct cpufreq_policy *policy,
		unsigned int event);
118
static unsigned int __cpufreq_get(struct cpufreq_policy *policy);
119
static void handle_update(struct work_struct *work);
Linus Torvalds's avatar
Linus Torvalds committed
120
121

/**
122
123
 * 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
124
125
126
127
 * "transition" list for kernel code that needs to handle
 * changes to devices when the CPU clock speed changes.
 * The mutex locks both lists.
 */
128
static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
129
static struct srcu_notifier_head cpufreq_transition_notifier_list;
Linus Torvalds's avatar
Linus Torvalds committed
130

131
static bool init_cpufreq_transition_notifier_list_called;
132
133
134
static int __init init_cpufreq_transition_notifier_list(void)
{
	srcu_init_notifier_head(&cpufreq_transition_notifier_list);
135
	init_cpufreq_transition_notifier_list_called = true;
136
137
	return 0;
}
138
pure_initcall(init_cpufreq_transition_notifier_list);
Linus Torvalds's avatar
Linus Torvalds committed
139

140
static int off __read_mostly;
141
static int cpufreq_disabled(void)
142
143
144
145
146
147
148
{
	return off;
}
void disable_cpufreq(void)
{
	off = 1;
}
149
static DEFINE_MUTEX(cpufreq_governor_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
150

151
152
bool have_governor_per_policy(void)
{
153
	return !!(cpufreq_driver->flags & CPUFREQ_HAVE_GOVERNOR_PER_POLICY);
154
}
155
EXPORT_SYMBOL_GPL(have_governor_per_policy);
156

157
158
159
160
161
162
163
164
165
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);

166
167
168
169
170
171
172
173
174
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);

175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
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);

210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
/*
 * 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;

	/*
232
	 * The driver only supports the SMP configuration where all processors
233
234
235
236
237
238
239
240
	 * share the clock and voltage and clock.
	 */
	cpumask_setall(policy->cpus);

	return 0;
}
EXPORT_SYMBOL_GPL(cpufreq_generic_init);

241
struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu)
242
243
244
{
	struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);

245
246
	return policy && cpumask_test_cpu(cpu, policy->cpus) ? policy : NULL;
}
247
EXPORT_SYMBOL_GPL(cpufreq_cpu_get_raw);
248
249
250
251
252

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

253
	if (!policy || IS_ERR(policy->clk)) {
254
255
		pr_err("%s: No %s associated to cpu: %d\n",
		       __func__, policy ? "clk" : "policy", cpu);
256
257
258
259
260
261
262
		return 0;
	}

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

263
264
265
266
267
268
269
270
271
272
273
274
275
/**
 * 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.
 */
276
struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
Linus Torvalds's avatar
Linus Torvalds committed
277
{
278
	struct cpufreq_policy *policy = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
279
280
	unsigned long flags;

281
	if (WARN_ON(cpu >= nr_cpu_ids))
282
283
		return NULL;

Linus Torvalds's avatar
Linus Torvalds committed
284
	/* get the cpufreq driver */
285
	read_lock_irqsave(&cpufreq_driver_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
286

287
288
	if (cpufreq_driver) {
		/* get the CPU */
289
		policy = cpufreq_cpu_get_raw(cpu);
290
291
292
		if (policy)
			kobject_get(&policy->kobj);
	}
Linus Torvalds's avatar
Linus Torvalds committed
293

294
	read_unlock_irqrestore(&cpufreq_driver_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
295

296
	return policy;
297
}
Linus Torvalds's avatar
Linus Torvalds committed
298
299
EXPORT_SYMBOL_GPL(cpufreq_cpu_get);

300
301
302
303
304
305
306
307
/**
 * 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().
 */
308
void cpufreq_cpu_put(struct cpufreq_policy *policy)
Linus Torvalds's avatar
Linus Torvalds committed
309
{
310
	kobject_put(&policy->kobj);
Linus Torvalds's avatar
Linus Torvalds committed
311
312
313
314
315
316
317
318
319
320
321
322
}
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
323
 * systems as each CPU might be scaled differently. So, use the arch
Linus Torvalds's avatar
Linus Torvalds committed
324
325
 * per-CPU loops_per_jiffy value wherever possible.
 */
326
static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
Linus Torvalds's avatar
Linus Torvalds committed
327
{
328
329
330
331
#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
332
333
334
335
336
337
	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;
338
339
		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
340
	}
341
	if (val == CPUFREQ_POSTCHANGE && ci->old != ci->new) {
342
343
		loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
								ci->new);
344
345
		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
346
347
	}
#endif
348
}
Linus Torvalds's avatar
Linus Torvalds committed
349

350
static void __cpufreq_notify_transition(struct cpufreq_policy *policy,
351
		struct cpufreq_freqs *freqs, unsigned int state)
Linus Torvalds's avatar
Linus Torvalds committed
352
353
354
{
	BUG_ON(irqs_disabled());

355
356
357
	if (cpufreq_disabled())
		return;

358
	freqs->flags = cpufreq_driver->flags;
359
	pr_debug("notification %u of frequency transition to %u kHz\n",
360
		 state, freqs->new);
Linus Torvalds's avatar
Linus Torvalds committed
361
362

	switch (state) {
363

Linus Torvalds's avatar
Linus Torvalds committed
364
	case CPUFREQ_PRECHANGE:
365
		/* detect if the driver reported a value as "old frequency"
366
367
		 * which is not equal to what the cpufreq core thinks is
		 * "old frequency".
Linus Torvalds's avatar
Linus Torvalds committed
368
		 */
369
		if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
370
371
			if ((policy) && (policy->cpu == freqs->cpu) &&
			    (policy->cur) && (policy->cur != freqs->old)) {
372
373
				pr_debug("Warning: CPU frequency is %u, cpufreq assumed %u kHz\n",
					 freqs->old, policy->cur);
374
				freqs->old = policy->cur;
Linus Torvalds's avatar
Linus Torvalds committed
375
376
			}
		}
377
		srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
378
				CPUFREQ_PRECHANGE, freqs);
Linus Torvalds's avatar
Linus Torvalds committed
379
380
		adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
		break;
381

Linus Torvalds's avatar
Linus Torvalds committed
382
383
	case CPUFREQ_POSTCHANGE:
		adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
384
385
		pr_debug("FREQ: %lu - CPU: %lu\n",
			 (unsigned long)freqs->new, (unsigned long)freqs->cpu);
386
		trace_cpu_frequency(freqs->new, freqs->cpu);
387
		srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
388
				CPUFREQ_POSTCHANGE, freqs);
389
390
		if (likely(policy) && likely(policy->cpu == freqs->cpu))
			policy->cur = freqs->new;
Linus Torvalds's avatar
Linus Torvalds committed
391
392
393
		break;
	}
}
394

395
396
397
398
399
400
401
402
/**
 * 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.
 */
403
static void cpufreq_notify_transition(struct cpufreq_policy *policy,
404
405
406
407
408
		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
409

410
/* Do post notifications when there are chances that transition has failed */
411
static void cpufreq_notify_post_transition(struct cpufreq_policy *policy,
412
413
414
415
416
417
418
419
420
421
422
		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);
}

423
424
425
void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
		struct cpufreq_freqs *freqs)
{
426
427
428
429
430
431
432
433
434
435
436
437

	/*
	 * 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);

438
439
440
441
442
443
444
445
446
447
448
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;
449
	policy->transition_task = current;
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465

	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;
466
	policy->transition_task = NULL;
467
468
469
470
471

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

Linus Torvalds's avatar
Linus Torvalds committed
472
473
474
475

/*********************************************************************
 *                          SYSFS INTERFACE                          *
 *********************************************************************/
476
static ssize_t show_boost(struct kobject *kobj,
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
				 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)) {
492
493
		pr_err("%s: Cannot %s BOOST!\n",
		       __func__, enable ? "enable" : "disable");
494
495
496
		return -EINVAL;
	}

497
498
	pr_debug("%s: cpufreq BOOST %s\n",
		 __func__, enable ? "enabled" : "disabled");
499
500
501
502

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

504
static struct cpufreq_governor *find_governor(const char *str_governor)
505
506
507
{
	struct cpufreq_governor *t;

508
	for_each_governor(t)
509
		if (!strncasecmp(str_governor, t->name, CPUFREQ_NAME_LEN))
510
511
512
513
514
			return t;

	return NULL;
}

Linus Torvalds's avatar
Linus Torvalds committed
515
516
517
/**
 * cpufreq_parse_governor - parse a governor string
 */
Dave Jones's avatar
Dave Jones committed
518
static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
Linus Torvalds's avatar
Linus Torvalds committed
519
520
				struct cpufreq_governor **governor)
{
521
	int err = -EINVAL;
522
523

	if (cpufreq_driver->setpolicy) {
524
		if (!strncasecmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
Linus Torvalds's avatar
Linus Torvalds committed
525
			*policy = CPUFREQ_POLICY_PERFORMANCE;
526
			err = 0;
527
		} else if (!strncasecmp(str_governor, "powersave",
528
						CPUFREQ_NAME_LEN)) {
Linus Torvalds's avatar
Linus Torvalds committed
529
			*policy = CPUFREQ_POLICY_POWERSAVE;
530
			err = 0;
Linus Torvalds's avatar
Linus Torvalds committed
531
		}
532
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
533
		struct cpufreq_governor *t;
534

535
		mutex_lock(&cpufreq_governor_mutex);
536

537
		t = find_governor(str_governor);
538

539
		if (t == NULL) {
540
			int ret;
541

542
543
544
			mutex_unlock(&cpufreq_governor_mutex);
			ret = request_module("cpufreq_%s", str_governor);
			mutex_lock(&cpufreq_governor_mutex);
545

546
			if (ret == 0)
547
				t = find_governor(str_governor);
548
549
		}

550
551
552
		if (t != NULL) {
			*governor = t;
			err = 0;
Linus Torvalds's avatar
Linus Torvalds committed
553
		}
554

555
		mutex_unlock(&cpufreq_governor_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
556
	}
557
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
558
559
560
}

/**
561
562
 * cpufreq_per_cpu_attr_read() / show_##file_name() -
 * print out cpufreq information
Linus Torvalds's avatar
Linus Torvalds committed
563
564
565
566
567
 *
 * Write out information from cpufreq_driver->policy[cpu]; object must be
 * "unsigned int".
 */

568
569
#define show_one(file_name, object)			\
static ssize_t show_##file_name				\
Dave Jones's avatar
Dave Jones committed
570
(struct cpufreq_policy *policy, char *buf)		\
571
{							\
572
	return sprintf(buf, "%u\n", policy->object);	\
Linus Torvalds's avatar
Linus Torvalds committed
573
574
575
576
}

show_one(cpuinfo_min_freq, cpuinfo.min_freq);
show_one(cpuinfo_max_freq, cpuinfo.max_freq);
577
show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
Linus Torvalds's avatar
Linus Torvalds committed
578
579
show_one(scaling_min_freq, min);
show_one(scaling_max_freq, max);
580

581
static ssize_t show_scaling_cur_freq(struct cpufreq_policy *policy, char *buf)
582
583
584
585
586
587
588
589
590
{
	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
591

592
static int cpufreq_set_policy(struct cpufreq_policy *policy,
593
				struct cpufreq_policy *new_policy);
594

Linus Torvalds's avatar
Linus Torvalds committed
595
596
597
598
599
/**
 * 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
600
(struct cpufreq_policy *policy, const char *buf, size_t count)		\
Linus Torvalds's avatar
Linus Torvalds committed
601
{									\
602
	int ret, temp;							\
Linus Torvalds's avatar
Linus Torvalds committed
603
604
	struct cpufreq_policy new_policy;				\
									\
605
	memcpy(&new_policy, policy, sizeof(*policy));			\
Linus Torvalds's avatar
Linus Torvalds committed
606
									\
607
	ret = sscanf(buf, "%u", &new_policy.object);			\
Linus Torvalds's avatar
Linus Torvalds committed
608
609
610
	if (ret != 1)							\
		return -EINVAL;						\
									\
611
	temp = new_policy.object;					\
612
	ret = cpufreq_set_policy(policy, &new_policy);		\
613
614
	if (!ret)							\
		policy->user_policy.object = temp;			\
Linus Torvalds's avatar
Linus Torvalds committed
615
616
617
618
									\
	return ret ? ret : count;					\
}

619
620
store_one(scaling_min_freq, min);
store_one(scaling_max_freq, max);
Linus Torvalds's avatar
Linus Torvalds committed
621
622
623
624

/**
 * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
 */
Dave Jones's avatar
Dave Jones committed
625
626
static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
					char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
627
{
628
	unsigned int cur_freq = __cpufreq_get(policy);
Linus Torvalds's avatar
Linus Torvalds committed
629
630
631
632
633
634
635
636
	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
637
static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
638
{
639
	if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
Linus Torvalds's avatar
Linus Torvalds committed
640
641
642
643
		return sprintf(buf, "powersave\n");
	else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
		return sprintf(buf, "performance\n");
	else if (policy->governor)
644
		return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n",
645
				policy->governor->name);
Linus Torvalds's avatar
Linus Torvalds committed
646
647
648
649
650
651
	return -EINVAL;
}

/**
 * store_scaling_governor - store policy for the specified CPU
 */
Dave Jones's avatar
Dave Jones committed
652
653
static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
					const char *buf, size_t count)
Linus Torvalds's avatar
Linus Torvalds committed
654
{
655
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
656
657
658
	char	str_governor[16];
	struct cpufreq_policy new_policy;

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

661
	ret = sscanf(buf, "%15s", str_governor);
Linus Torvalds's avatar
Linus Torvalds committed
662
663
664
	if (ret != 1)
		return -EINVAL;

665
666
	if (cpufreq_parse_governor(str_governor, &new_policy.policy,
						&new_policy.governor))
Linus Torvalds's avatar
Linus Torvalds committed
667
668
		return -EINVAL;

669
	ret = cpufreq_set_policy(policy, &new_policy);
670
	return ret ? ret : count;
Linus Torvalds's avatar
Linus Torvalds committed
671
672
673
674
675
}

/**
 * show_scaling_driver - show the cpufreq driver currently loaded
 */
Dave Jones's avatar
Dave Jones committed
676
static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
677
{
678
	return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n", cpufreq_driver->name);
Linus Torvalds's avatar
Linus Torvalds committed
679
680
681
682
683
}

/**
 * show_scaling_available_governors - show the available CPUfreq governors
 */
Dave Jones's avatar
Dave Jones committed
684
685
static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
						char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
686
687
688
689
{
	ssize_t i = 0;
	struct cpufreq_governor *t;

690
	if (!has_target()) {
Linus Torvalds's avatar
Linus Torvalds committed
691
692
693
694
		i += sprintf(buf, "performance powersave");
		goto out;
	}

695
	for_each_governor(t) {
696
697
		if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
		    - (CPUFREQ_NAME_LEN + 2)))
Linus Torvalds's avatar
Linus Torvalds committed
698
			goto out;
699
		i += scnprintf(&buf[i], CPUFREQ_NAME_PLEN, "%s ", t->name);
Linus Torvalds's avatar
Linus Torvalds committed
700
	}
701
out:
Linus Torvalds's avatar
Linus Torvalds committed
702
703
704
	i += sprintf(&buf[i], "\n");
	return i;
}
705

706
ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
707
708
709
710
{
	ssize_t i = 0;
	unsigned int cpu;

711
	for_each_cpu(cpu, mask) {
Linus Torvalds's avatar
Linus Torvalds committed
712
713
714
715
		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))
716
			break;
Linus Torvalds's avatar
Linus Torvalds committed
717
718
719
720
	}
	i += sprintf(&buf[i], "\n");
	return i;
}
721
EXPORT_SYMBOL_GPL(cpufreq_show_cpus);
Linus Torvalds's avatar
Linus Torvalds committed
722

723
724
725
726
727
728
/**
 * 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)
{
729
	return cpufreq_show_cpus(policy->related_cpus, buf);
730
731
732
733
734
735
736
}

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

740
static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
Dave Jones's avatar
Dave Jones committed
741
					const char *buf, size_t count)
742
743
744
745
{
	unsigned int freq = 0;
	unsigned int ret;

746
	if (!policy->governor || !policy->governor->store_setspeed)
747
748
749
750
751
752
753
754
755
756
757
758
759
		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)
{
760
	if (!policy->governor || !policy->governor->show_setspeed)
761
762
763
764
		return sprintf(buf, "<unsupported>\n");

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

766
/**
767
 * show_bios_limit - show the current cpufreq HW/BIOS limitation
768
769
770
771
772
 */
static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
{
	unsigned int limit;
	int ret;
773
774
	if (cpufreq_driver->bios_limit) {
		ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
775
776
777
778
779
780
		if (!ret)
			return sprintf(buf, "%u\n", limit);
	}
	return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
}

781
782
783
784
785
786
787
788
789
790
791
792
793
794
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
795

Dave Jones's avatar
Dave Jones committed
796
static struct attribute *default_attrs[] = {
Linus Torvalds's avatar
Linus Torvalds committed
797
798
	&cpuinfo_min_freq.attr,
	&cpuinfo_max_freq.attr,
799
	&cpuinfo_transition_latency.attr,
Linus Torvalds's avatar
Linus Torvalds committed
800
801
802
	&scaling_min_freq.attr,
	&scaling_max_freq.attr,
	&affected_cpus.attr,
803
	&related_cpus.attr,
Linus Torvalds's avatar
Linus Torvalds committed
804
805
806
	&scaling_governor.attr,
	&scaling_driver.attr,
	&scaling_available_governors.attr,
807
	&scaling_setspeed.attr,
Linus Torvalds's avatar
Linus Torvalds committed
808
809
810
	NULL
};

811
812
#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
813

814
static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
815
{
Dave Jones's avatar
Dave Jones committed
816
817
	struct cpufreq_policy *policy = to_policy(kobj);
	struct freq_attr *fattr = to_attr(attr);
818
	ssize_t ret;
819

820
	down_read(&policy->rwsem);
821

822
823
824
825
826
	if (fattr->show)
		ret = fattr->show(policy, buf);
	else
		ret = -EIO;

827
	up_read(&policy->rwsem);
828

Linus Torvalds's avatar
Linus Torvalds committed
829
830
831
	return ret;
}

Dave Jones's avatar
Dave Jones committed
832
833
static ssize_t store(struct kobject *kobj, struct attribute *attr,
		     const char *buf, size_t count)
Linus Torvalds's avatar
Linus Torvalds committed
834
{
Dave Jones's avatar
Dave Jones committed
835
836
	struct cpufreq_policy *policy = to_policy(kobj);
	struct freq_attr *fattr = to_attr(attr);
837
	ssize_t ret = -EINVAL;
838

839
840
841
842
843
	get_online_cpus();

	if (!cpu_online(policy->cpu))
		goto unlock;

844
	down_write(&policy->rwsem);
845

846
847
848
849
850
	if (fattr->store)
		ret = fattr->store(policy, buf, count);
	else
		ret = -EIO;

851
	up_write(&policy->rwsem);
852
853
854
unlock:
	put_online_cpus();

Linus Torvalds's avatar
Linus Torvalds committed
855
856
857
	return ret;
}

Dave Jones's avatar
Dave Jones committed
858
static void cpufreq_sysfs_release(struct kobject *kobj)
Linus Torvalds's avatar
Linus Torvalds committed
859
{
Dave Jones's avatar
Dave Jones committed
860
	struct cpufreq_policy *policy = to_policy(kobj);
861
	pr_debug("last reference is dropped\n");
Linus Torvalds's avatar
Linus Torvalds committed
862
863
864
	complete(&policy->kobj_unregister);
}

865
static const struct sysfs_ops sysfs_ops = {
Linus Torvalds's avatar
Linus Torvalds committed
866
867
868
869
870
871
872
873
874
875
	.show	= show,
	.store	= store,
};

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

876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
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 */
906
static int cpufreq_add_dev_symlink(struct cpufreq_policy *policy)
907
908
909
910
{
	unsigned int j;
	int ret = 0;

911
	/* Some related CPUs might not be present (physically hotplugged) */
912
	for_each_cpu(j, policy->real_cpus) {
913
		ret = add_cpu_dev_symlink(policy, j);
914
915
		if (ret)
			break;
916
	}
917

918
919
920
	return ret;
}

921
922
923
924
925
static void cpufreq_remove_dev_symlink(struct cpufreq_policy *policy)
{
	unsigned int j;

	/* Some related CPUs might not be present (physically hotplugged) */
926
	for_each_cpu(j, policy->real_cpus)
927
928
929
		remove_cpu_dev_symlink(policy, j);
}

930
static int cpufreq_add_dev_interface(struct cpufreq_policy *policy)
931
932
933
934
935
{
	struct freq_attr **drv_attr;
	int ret = 0;

	/* set up files for this cpu device */
936
	drv_attr = cpufreq_driver->attr;
937
	while (drv_attr && *drv_attr) {
938
939
		ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
		if (ret)
940
			return ret;
941
942
		drv_attr++;
	}
943
	if (cpufreq_driver->get) {
944
945
		ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
		if (ret)
946
			return ret;
947
	}
948
949
950

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

953
	if (cpufreq_driver->bios_limit) {
954
955
		ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
		if (ret)
956
			return ret;
957
	}
958

959
	return cpufreq_add_dev_symlink(policy);
960
961
}

962
static int cpufreq_init_policy(struct cpufreq_policy *policy)
963
{
964
	struct cpufreq_governor *gov = NULL;
965
966
	struct cpufreq_policy new_policy;

967
	memcpy(&new_policy, policy, sizeof(*policy));
968

969
	/* Update governor of new_policy to the governor used before hotplug */
970
	gov = find_governor(policy->last_governor);
971
972
973
974
975
976
977
978
	if (gov)
		pr_debug("Restoring governor %s for cpu %d\n",
				policy->governor->name, policy->cpu);
	else
		gov = CPUFREQ_DEFAULT_GOVERNOR;

	new_policy.governor = gov;

979
980
	/* Use the default policy if its valid. */
	if (cpufreq_driver->setpolicy)
981
		cpufreq_parse_governor(gov->name, &new_policy.policy, NULL);
982
983

	/* set default policy */
984
	return cpufreq_set_policy(policy, &new_policy);
985
986
}

987
static int cpufreq_add_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
988
{
989
	int ret = 0;
990

991
992
993
994
	/* Has this CPU been taken care of already? */
	if (cpumask_test_cpu(cpu, policy->cpus))
		return 0;

995
	if (has_target()) {
996
997
998
999
1000
		ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
		if (ret) {
			pr_err("%s: Failed to stop governor\n", __func__);
			return ret;
		}
For faster browsing, not all history is shown. View entire blame