cpufreq.c 65.4 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

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 {
		/* No more policies in the list */
52
		if (list_is_last(&policy->policy_list, &cpufreq_policy_list))
53
			return NULL;
54
55

		policy = list_next_entry(policy, policy_list);
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
	} 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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

static DEFINE_PER_CPU(struct update_util_data *, cpufreq_update_util_data);

/**
 * cpufreq_set_update_util_data - Populate the CPU's update_util_data pointer.
 * @cpu: The CPU to set the pointer for.
 * @data: New pointer value.
 *
 * Set and publish the update_util_data pointer for the given CPU.  That pointer
 * points to a struct update_util_data object containing a callback function
 * to call from cpufreq_update_util().  That function will be called from an RCU
 * read-side critical section, so it must not sleep.
 *
 * Callers must use RCU callbacks to free any memory that might be accessed
 * via the old update_util_data pointer or invoke synchronize_rcu() right after
 * this function to avoid use-after-free.
 */
void cpufreq_set_update_util_data(int cpu, struct update_util_data *data)
{
	rcu_assign_pointer(per_cpu(cpufreq_update_util_data, cpu), data);
}
EXPORT_SYMBOL_GPL(cpufreq_set_update_util_data);

/**
 * cpufreq_update_util - Take a note about CPU utilization changes.
 * @time: Current time.
 * @util: Current utilization.
 * @max: Utilization ceiling.
 *
 * This function is called by the scheduler on every invocation of
 * update_load_avg() on the CPU whose utilization is being updated.
 */
void cpufreq_update_util(u64 time, unsigned long util, unsigned long max)
{
	struct update_util_data *data;

	rcu_read_lock();

	data = rcu_dereference(*this_cpu_ptr(&cpufreq_update_util_data));
	if (data && data->func)
		data->func(data, time, util, max);

	rcu_read_unlock();
}

150
151
/* Flag to suspend/resume CPUFreq governors */
static bool cpufreq_suspended;
Linus Torvalds's avatar
Linus Torvalds committed
152

153
154
155
156
157
static inline bool has_target(void)
{
	return cpufreq_driver->target_index || cpufreq_driver->target;
}

Linus Torvalds's avatar
Linus Torvalds committed
158
/* internal prototypes */
159
static int cpufreq_governor(struct cpufreq_policy *policy, unsigned int event);
160
static unsigned int __cpufreq_get(struct cpufreq_policy *policy);
Linus Torvalds's avatar
Linus Torvalds committed
161
162

/**
163
164
 * 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
165
166
167
168
 * "transition" list for kernel code that needs to handle
 * changes to devices when the CPU clock speed changes.
 * The mutex locks both lists.
 */
169
static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
170
static struct srcu_notifier_head cpufreq_transition_notifier_list;
Linus Torvalds's avatar
Linus Torvalds committed
171

172
static bool init_cpufreq_transition_notifier_list_called;
173
174
175
static int __init init_cpufreq_transition_notifier_list(void)
{
	srcu_init_notifier_head(&cpufreq_transition_notifier_list);
176
	init_cpufreq_transition_notifier_list_called = true;
177
178
	return 0;
}
179
pure_initcall(init_cpufreq_transition_notifier_list);
Linus Torvalds's avatar
Linus Torvalds committed
180

181
static int off __read_mostly;
182
static int cpufreq_disabled(void)
183
184
185
186
187
188
189
{
	return off;
}
void disable_cpufreq(void)
{
	off = 1;
}
190
static DEFINE_MUTEX(cpufreq_governor_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
191

192
193
bool have_governor_per_policy(void)
{
194
	return !!(cpufreq_driver->flags & CPUFREQ_HAVE_GOVERNOR_PER_POLICY);
195
}
196
EXPORT_SYMBOL_GPL(have_governor_per_policy);
197

198
199
200
201
202
203
204
205
206
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);

207
208
209
210
211
212
213
214
215
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);

216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
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);

251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
/*
 * 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;

	/*
273
	 * The driver only supports the SMP configuration where all processors
274
275
276
277
278
279
280
281
	 * share the clock and voltage and clock.
	 */
	cpumask_setall(policy->cpus);

	return 0;
}
EXPORT_SYMBOL_GPL(cpufreq_generic_init);

282
struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu)
283
284
285
{
	struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);

286
287
	return policy && cpumask_test_cpu(cpu, policy->cpus) ? policy : NULL;
}
288
EXPORT_SYMBOL_GPL(cpufreq_cpu_get_raw);
289
290
291
292
293

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

294
	if (!policy || IS_ERR(policy->clk)) {
295
296
		pr_err("%s: No %s associated to cpu: %d\n",
		       __func__, policy ? "clk" : "policy", cpu);
297
298
299
300
301
302
303
		return 0;
	}

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

304
305
306
307
308
309
310
311
312
313
314
315
316
/**
 * 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.
 */
317
struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
Linus Torvalds's avatar
Linus Torvalds committed
318
{
319
	struct cpufreq_policy *policy = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
320
321
	unsigned long flags;

322
	if (WARN_ON(cpu >= nr_cpu_ids))
323
324
		return NULL;

Linus Torvalds's avatar
Linus Torvalds committed
325
	/* get the cpufreq driver */
326
	read_lock_irqsave(&cpufreq_driver_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
327

328
329
	if (cpufreq_driver) {
		/* get the CPU */
330
		policy = cpufreq_cpu_get_raw(cpu);
331
332
333
		if (policy)
			kobject_get(&policy->kobj);
	}
Linus Torvalds's avatar
Linus Torvalds committed
334

335
	read_unlock_irqrestore(&cpufreq_driver_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
336

337
	return policy;
338
}
Linus Torvalds's avatar
Linus Torvalds committed
339
340
EXPORT_SYMBOL_GPL(cpufreq_cpu_get);

341
342
343
344
345
346
347
348
/**
 * 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().
 */
349
void cpufreq_cpu_put(struct cpufreq_policy *policy)
Linus Torvalds's avatar
Linus Torvalds committed
350
{
351
	kobject_put(&policy->kobj);
Linus Torvalds's avatar
Linus Torvalds committed
352
353
354
355
356
357
358
359
360
361
362
363
}
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
364
 * systems as each CPU might be scaled differently. So, use the arch
Linus Torvalds's avatar
Linus Torvalds committed
365
366
 * per-CPU loops_per_jiffy value wherever possible.
 */
367
static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
Linus Torvalds's avatar
Linus Torvalds committed
368
{
369
370
371
372
#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
373
374
375
376
377
378
	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;
379
380
		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
381
	}
382
	if (val == CPUFREQ_POSTCHANGE && ci->old != ci->new) {
383
384
		loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
								ci->new);
385
386
		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
387
388
	}
#endif
389
}
Linus Torvalds's avatar
Linus Torvalds committed
390

391
static void __cpufreq_notify_transition(struct cpufreq_policy *policy,
392
		struct cpufreq_freqs *freqs, unsigned int state)
Linus Torvalds's avatar
Linus Torvalds committed
393
394
395
{
	BUG_ON(irqs_disabled());

396
397
398
	if (cpufreq_disabled())
		return;

399
	freqs->flags = cpufreq_driver->flags;
400
	pr_debug("notification %u of frequency transition to %u kHz\n",
401
		 state, freqs->new);
Linus Torvalds's avatar
Linus Torvalds committed
402
403

	switch (state) {
404

Linus Torvalds's avatar
Linus Torvalds committed
405
	case CPUFREQ_PRECHANGE:
406
		/* detect if the driver reported a value as "old frequency"
407
408
		 * which is not equal to what the cpufreq core thinks is
		 * "old frequency".
Linus Torvalds's avatar
Linus Torvalds committed
409
		 */
410
		if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
411
412
			if ((policy) && (policy->cpu == freqs->cpu) &&
			    (policy->cur) && (policy->cur != freqs->old)) {
413
414
				pr_debug("Warning: CPU frequency is %u, cpufreq assumed %u kHz\n",
					 freqs->old, policy->cur);
415
				freqs->old = policy->cur;
Linus Torvalds's avatar
Linus Torvalds committed
416
417
			}
		}
418
		srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
419
				CPUFREQ_PRECHANGE, freqs);
Linus Torvalds's avatar
Linus Torvalds committed
420
421
		adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
		break;
422

Linus Torvalds's avatar
Linus Torvalds committed
423
424
	case CPUFREQ_POSTCHANGE:
		adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
425
426
		pr_debug("FREQ: %lu - CPU: %lu\n",
			 (unsigned long)freqs->new, (unsigned long)freqs->cpu);
427
		trace_cpu_frequency(freqs->new, freqs->cpu);
428
		srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
429
				CPUFREQ_POSTCHANGE, freqs);
430
431
		if (likely(policy) && likely(policy->cpu == freqs->cpu))
			policy->cur = freqs->new;
Linus Torvalds's avatar
Linus Torvalds committed
432
433
434
		break;
	}
}
435

436
437
438
439
440
441
442
443
/**
 * 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.
 */
444
static void cpufreq_notify_transition(struct cpufreq_policy *policy,
445
446
447
448
449
		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
450

451
/* Do post notifications when there are chances that transition has failed */
452
static void cpufreq_notify_post_transition(struct cpufreq_policy *policy,
453
454
455
456
457
458
459
460
461
462
463
		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);
}

464
465
466
void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
		struct cpufreq_freqs *freqs)
{
467
468
469
470
471
472
473
474
475
476
477
478

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

479
480
481
482
483
484
485
486
487
488
489
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;
490
	policy->transition_task = current;
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506

	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;
507
	policy->transition_task = NULL;
508
509
510
511
512

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

Linus Torvalds's avatar
Linus Torvalds committed
513
514
515
516

/*********************************************************************
 *                          SYSFS INTERFACE                          *
 *********************************************************************/
517
static ssize_t show_boost(struct kobject *kobj,
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
				 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)) {
533
534
		pr_err("%s: Cannot %s BOOST!\n",
		       __func__, enable ? "enable" : "disable");
535
536
537
		return -EINVAL;
	}

538
539
	pr_debug("%s: cpufreq BOOST %s\n",
		 __func__, enable ? "enabled" : "disabled");
540
541
542
543

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

545
static struct cpufreq_governor *find_governor(const char *str_governor)
546
547
548
{
	struct cpufreq_governor *t;

549
	for_each_governor(t)
550
		if (!strncasecmp(str_governor, t->name, CPUFREQ_NAME_LEN))
551
552
553
554
555
			return t;

	return NULL;
}

Linus Torvalds's avatar
Linus Torvalds committed
556
557
558
/**
 * cpufreq_parse_governor - parse a governor string
 */
Dave Jones's avatar
Dave Jones committed
559
static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
Linus Torvalds's avatar
Linus Torvalds committed
560
561
				struct cpufreq_governor **governor)
{
562
	int err = -EINVAL;
563
564

	if (cpufreq_driver->setpolicy) {
565
		if (!strncasecmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
Linus Torvalds's avatar
Linus Torvalds committed
566
			*policy = CPUFREQ_POLICY_PERFORMANCE;
567
			err = 0;
568
		} else if (!strncasecmp(str_governor, "powersave",
569
						CPUFREQ_NAME_LEN)) {
Linus Torvalds's avatar
Linus Torvalds committed
570
			*policy = CPUFREQ_POLICY_POWERSAVE;
571
			err = 0;
Linus Torvalds's avatar
Linus Torvalds committed
572
		}
573
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
574
		struct cpufreq_governor *t;
575

576
		mutex_lock(&cpufreq_governor_mutex);
577

578
		t = find_governor(str_governor);
579

580
		if (t == NULL) {
581
			int ret;
582

583
584
585
			mutex_unlock(&cpufreq_governor_mutex);
			ret = request_module("cpufreq_%s", str_governor);
			mutex_lock(&cpufreq_governor_mutex);
586

587
			if (ret == 0)
588
				t = find_governor(str_governor);
589
590
		}

591
592
593
		if (t != NULL) {
			*governor = t;
			err = 0;
Linus Torvalds's avatar
Linus Torvalds committed
594
		}
595

596
		mutex_unlock(&cpufreq_governor_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
597
	}
598
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
599
600
601
}

/**
602
603
 * cpufreq_per_cpu_attr_read() / show_##file_name() -
 * print out cpufreq information
Linus Torvalds's avatar
Linus Torvalds committed
604
605
606
607
608
 *
 * Write out information from cpufreq_driver->policy[cpu]; object must be
 * "unsigned int".
 */

609
610
#define show_one(file_name, object)			\
static ssize_t show_##file_name				\
Dave Jones's avatar
Dave Jones committed
611
(struct cpufreq_policy *policy, char *buf)		\
612
{							\
613
	return sprintf(buf, "%u\n", policy->object);	\
Linus Torvalds's avatar
Linus Torvalds committed
614
615
616
617
}

show_one(cpuinfo_min_freq, cpuinfo.min_freq);
show_one(cpuinfo_max_freq, cpuinfo.max_freq);
618
show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
Linus Torvalds's avatar
Linus Torvalds committed
619
620
show_one(scaling_min_freq, min);
show_one(scaling_max_freq, max);
621

622
static ssize_t show_scaling_cur_freq(struct cpufreq_policy *policy, char *buf)
623
624
625
626
627
628
629
630
631
{
	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
632

633
static int cpufreq_set_policy(struct cpufreq_policy *policy,
634
				struct cpufreq_policy *new_policy);
635

Linus Torvalds's avatar
Linus Torvalds committed
636
637
638
639
640
/**
 * 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
641
(struct cpufreq_policy *policy, const char *buf, size_t count)		\
Linus Torvalds's avatar
Linus Torvalds committed
642
{									\
643
	int ret, temp;							\
Linus Torvalds's avatar
Linus Torvalds committed
644
645
	struct cpufreq_policy new_policy;				\
									\
646
	memcpy(&new_policy, policy, sizeof(*policy));			\
Linus Torvalds's avatar
Linus Torvalds committed
647
									\
648
	ret = sscanf(buf, "%u", &new_policy.object);			\
Linus Torvalds's avatar
Linus Torvalds committed
649
650
651
	if (ret != 1)							\
		return -EINVAL;						\
									\
652
	temp = new_policy.object;					\
653
	ret = cpufreq_set_policy(policy, &new_policy);		\
654
655
	if (!ret)							\
		policy->user_policy.object = temp;			\
Linus Torvalds's avatar
Linus Torvalds committed
656
657
658
659
									\
	return ret ? ret : count;					\
}

660
661
store_one(scaling_min_freq, min);
store_one(scaling_max_freq, max);
Linus Torvalds's avatar
Linus Torvalds committed
662
663
664
665

/**
 * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
 */
Dave Jones's avatar
Dave Jones committed
666
667
static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
					char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
668
{
669
	unsigned int cur_freq = __cpufreq_get(policy);
Linus Torvalds's avatar
Linus Torvalds committed
670
671
672
673
674
675
676
677
	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
678
static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
679
{
680
	if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
Linus Torvalds's avatar
Linus Torvalds committed
681
682
683
684
		return sprintf(buf, "powersave\n");
	else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
		return sprintf(buf, "performance\n");
	else if (policy->governor)
685
		return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n",
686
				policy->governor->name);
Linus Torvalds's avatar
Linus Torvalds committed
687
688
689
690
691
692
	return -EINVAL;
}

/**
 * store_scaling_governor - store policy for the specified CPU
 */
Dave Jones's avatar
Dave Jones committed
693
694
static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
					const char *buf, size_t count)
Linus Torvalds's avatar
Linus Torvalds committed
695
{
696
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
697
698
699
	char	str_governor[16];
	struct cpufreq_policy new_policy;

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

702
	ret = sscanf(buf, "%15s", str_governor);
Linus Torvalds's avatar
Linus Torvalds committed
703
704
705
	if (ret != 1)
		return -EINVAL;

706
707
	if (cpufreq_parse_governor(str_governor, &new_policy.policy,
						&new_policy.governor))
Linus Torvalds's avatar
Linus Torvalds committed
708
709
		return -EINVAL;

710
	ret = cpufreq_set_policy(policy, &new_policy);
711
	return ret ? ret : count;
Linus Torvalds's avatar
Linus Torvalds committed
712
713
714
715
716
}

/**
 * show_scaling_driver - show the cpufreq driver currently loaded
 */
Dave Jones's avatar
Dave Jones committed
717
static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
718
{
719
	return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n", cpufreq_driver->name);
Linus Torvalds's avatar
Linus Torvalds committed
720
721
722
723
724
}

/**
 * show_scaling_available_governors - show the available CPUfreq governors
 */
Dave Jones's avatar
Dave Jones committed
725
726
static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
						char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
727
728
729
730
{
	ssize_t i = 0;
	struct cpufreq_governor *t;

731
	if (!has_target()) {
Linus Torvalds's avatar
Linus Torvalds committed
732
733
734
735
		i += sprintf(buf, "performance powersave");
		goto out;
	}

736
	for_each_governor(t) {
737
738
		if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
		    - (CPUFREQ_NAME_LEN + 2)))
Linus Torvalds's avatar
Linus Torvalds committed
739
			goto out;
740
		i += scnprintf(&buf[i], CPUFREQ_NAME_PLEN, "%s ", t->name);
Linus Torvalds's avatar
Linus Torvalds committed
741
	}
742
out:
Linus Torvalds's avatar
Linus Torvalds committed
743
744
745
	i += sprintf(&buf[i], "\n");
	return i;
}
746

747
ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
748
749
750
751
{
	ssize_t i = 0;
	unsigned int cpu;

752
	for_each_cpu(cpu, mask) {
Linus Torvalds's avatar
Linus Torvalds committed
753
754
755
756
		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))
757
			break;
Linus Torvalds's avatar
Linus Torvalds committed
758
759
760
761
	}
	i += sprintf(&buf[i], "\n");
	return i;
}
762
EXPORT_SYMBOL_GPL(cpufreq_show_cpus);
Linus Torvalds's avatar
Linus Torvalds committed
763

764
765
766
767
768
769
/**
 * 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)
{
770
	return cpufreq_show_cpus(policy->related_cpus, buf);
771
772
773
774
775
776
777
}

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

781
static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
Dave Jones's avatar
Dave Jones committed
782
					const char *buf, size_t count)
783
784
785
786
{
	unsigned int freq = 0;
	unsigned int ret;

787
	if (!policy->governor || !policy->governor->store_setspeed)
788
789
790
791
792
793
794
795
796
797
798
799
800
		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)
{
801
	if (!policy->governor || !policy->governor->show_setspeed)
802
803
804
805
		return sprintf(buf, "<unsupported>\n");

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

807
/**
808
 * show_bios_limit - show the current cpufreq HW/BIOS limitation
809
810
811
812
813
 */
static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
{
	unsigned int limit;
	int ret;
814
815
	if (cpufreq_driver->bios_limit) {
		ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
816
817
818
819
820
821
		if (!ret)
			return sprintf(buf, "%u\n", limit);
	}
	return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
}

822
823
824
825
826
827
828
829
830
831
832
833
834
835
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
836

Dave Jones's avatar
Dave Jones committed
837
static struct attribute *default_attrs[] = {
Linus Torvalds's avatar
Linus Torvalds committed
838
839
	&cpuinfo_min_freq.attr,
	&cpuinfo_max_freq.attr,
840
	&cpuinfo_transition_latency.attr,
Linus Torvalds's avatar
Linus Torvalds committed
841
842
843
	&scaling_min_freq.attr,
	&scaling_max_freq.attr,
	&affected_cpus.attr,
844
	&related_cpus.attr,
Linus Torvalds's avatar
Linus Torvalds committed
845
846
847
	&scaling_governor.attr,
	&scaling_driver.attr,
	&scaling_available_governors.attr,
848
	&scaling_setspeed.attr,
Linus Torvalds's avatar
Linus Torvalds committed
849
850
851
	NULL
};

852
853
#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
854

855
static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
856
{
Dave Jones's avatar
Dave Jones committed
857
858
	struct cpufreq_policy *policy = to_policy(kobj);
	struct freq_attr *fattr = to_attr(attr);
859
	ssize_t ret;
860

861
	down_read(&policy->rwsem);
862

863
864
865
866
867
	if (fattr->show)
		ret = fattr->show(policy, buf);
	else
		ret = -EIO;

868
	up_read(&policy->rwsem);
869

Linus Torvalds's avatar
Linus Torvalds committed
870
871
872
	return ret;
}

Dave Jones's avatar
Dave Jones committed
873
874
static ssize_t store(struct kobject *kobj, struct attribute *attr,
		     const char *buf, size_t count)
Linus Torvalds's avatar
Linus Torvalds committed
875
{
Dave Jones's avatar
Dave Jones committed
876
877
	struct cpufreq_policy *policy = to_policy(kobj);
	struct freq_attr *fattr = to_attr(attr);
878
	ssize_t ret = -EINVAL;
879

880
881
882
883
884
	get_online_cpus();

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

885
	down_write(&policy->rwsem);
886

887
888
889
890
891
	if (fattr->store)
		ret = fattr->store(policy, buf, count);
	else
		ret = -EIO;

892
	up_write(&policy->rwsem);
893
894
895
unlock:
	put_online_cpus();

Linus Torvalds's avatar
Linus Torvalds committed
896
897
898
	return ret;
}

Dave Jones's avatar
Dave Jones committed
899
static void cpufreq_sysfs_release(struct kobject *kobj)
Linus Torvalds's avatar
Linus Torvalds committed
900
{
Dave Jones's avatar
Dave Jones committed
901
	struct cpufreq_policy *policy = to_policy(kobj);
902
	pr_debug("last reference is dropped\n");
Linus Torvalds's avatar
Linus Torvalds committed
903
904
905
	complete(&policy->kobj_unregister);
}

906
static const struct sysfs_ops sysfs_ops = {
Linus Torvalds's avatar
Linus Torvalds committed
907
908
909
910
911
912
913
914
915
916
	.show	= show,
	.store	= store,
};

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

917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
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 */
947
static int cpufreq_add_dev_symlink(struct cpufreq_policy *policy)
948
949
950
951
{
	unsigned int j;
	int ret = 0;

952
	/* Some related CPUs might not be present (physically hotplugged) */
953
	for_each_cpu(j, policy->real_cpus) {
954
		ret = add_cpu_dev_symlink(policy, j);
955
956
		if (ret)
			break;
957
	}
958

959
960
961
	return ret;
}

962
963
964
965
966
static void cpufreq_remove_dev_symlink(struct cpufreq_policy *policy)
{
	unsigned int j;

	/* Some related CPUs might not be present (physically hotplugged) */
967
	for_each_cpu(j, policy->real_cpus)
968
969
970
		remove_cpu_dev_symlink(policy, j);
}

971
static int cpufreq_add_dev_interface(struct cpufreq_policy *policy)
972
973
974
975
976
{
	struct freq_attr **drv_attr;
	int ret = 0;

	/* set up files for this cpu device */
977
	drv_attr = cpufreq_driver->attr;
978
	while (drv_attr && *drv_attr) {
979
980
		ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
		if (ret)
981
			return ret;
982
983
		drv_attr++;
	}
984
	if (cpufreq_driver->get) {
985
986
		ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
		if (ret)
987
			return ret;
988
	}
989
990
991

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

994
	if (cpufreq_driver->bios_limit) {
995
996
		ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
		if (ret)
997
			return ret;
998
	}
999

1000
	return cpufreq_add_dev_symlink(policy);
For faster browsing, not all history is shown. View entire blame