cpufreq.c 65.5 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
160
static int __cpufreq_governor(struct cpufreq_policy *policy,
		unsigned int event);
161
static unsigned int __cpufreq_get(struct cpufreq_policy *policy);
162
static void handle_update(struct work_struct *work);
Linus Torvalds's avatar
Linus Torvalds committed
163
164

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

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

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

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

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

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

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
251
252
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);

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

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

	return 0;
}
EXPORT_SYMBOL_GPL(cpufreq_generic_init);

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

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

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

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

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

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

324
	if (WARN_ON(cpu >= nr_cpu_ids))
325
326
		return NULL;

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

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

337
	read_unlock_irqrestore(&cpufreq_driver_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
338

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

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

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

398
399
400
	if (cpufreq_disabled())
		return;

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

	switch (state) {
406

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

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

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

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

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

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

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

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

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

Linus Torvalds's avatar
Linus Torvalds committed
515
516
517
518

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

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

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

547
static struct cpufreq_governor *find_governor(const char *str_governor)
548
549
550
{
	struct cpufreq_governor *t;

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

	return NULL;
}

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

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

578
		mutex_lock(&cpufreq_governor_mutex);
579

580
		t = find_governor(str_governor);
581

582
		if (t == NULL) {
583
			int ret;
584

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

589
			if (ret == 0)
590
				t = find_governor(str_governor);
591
592
		}

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

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

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

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

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

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

635
static int cpufreq_set_policy(struct cpufreq_policy *policy,
636
				struct cpufreq_policy *new_policy);
637

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

854
855
#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
856

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

863
	down_read(&policy->rwsem);
864

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

870
	up_read(&policy->rwsem);
871

Linus Torvalds's avatar
Linus Torvalds committed
872
873
874
	return ret;
}

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

882
883
884
885
886
	get_online_cpus();

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

887
	down_write(&policy->rwsem);
888

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

894
	up_write(&policy->rwsem);
895
896
897
unlock:
	put_online_cpus();

Linus Torvalds's avatar
Linus Torvalds committed
898
899
900
	return ret;
}

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

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

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

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
947
948
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 */
949
static int cpufreq_add_dev_symlink(struct cpufreq_policy *policy)
950
951
952
953
{
	unsigned int j;
	int ret = 0;

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

961
962
963
	return ret;
}

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

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

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

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

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

996
	if (cpufreq_driver->bios_limit) {
997
998
		ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
		if (ret)
999
			return ret;
1000
	}
For faster browsing, not all history is shown. View entire blame