cpufreq.c 48.6 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
/*
 *  linux/drivers/cpufreq/cpufreq.c
 *
 *  Copyright (C) 2001 Russell King
 *            (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
 *
7
 *  Oct 2005 - Ashok Raj <ashok.raj@intel.com>
8
 *	Added handling for CPU hotplug
9
10
 *  Feb 2006 - Jacob Shin <jacob.shin@amd.com>
 *	Fix handling for CPU hotplug -- affected CPUs
11
 *
Linus Torvalds's avatar
Linus Torvalds committed
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 * 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.
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/notifier.h>
#include <linux/cpufreq.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/cpu.h>
#include <linux/completion.h>
30
#include <linux/mutex.h>
Linus Torvalds's avatar
Linus Torvalds committed
31

32
33
#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, \
						"cpufreq-core", msg)
Linus Torvalds's avatar
Linus Torvalds committed
34
35

/**
Dave Jones's avatar
Dave Jones committed
36
 * The "cpufreq driver" - the arch- or hardware-dependent low
Linus Torvalds's avatar
Linus Torvalds committed
37
38
39
 * level driver of CPUFreq support, and its spinlock. This lock
 * also protects the cpufreq_cpu_data array.
 */
40
static struct cpufreq_driver *cpufreq_driver;
41
static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
42
43
#ifdef CONFIG_HOTPLUG_CPU
/* This one keeps track of the previously set governor of a removed CPU */
44
static DEFINE_PER_CPU(struct cpufreq_governor *, cpufreq_cpu_governor);
45
#endif
Linus Torvalds's avatar
Linus Torvalds committed
46
47
static DEFINE_SPINLOCK(cpufreq_driver_lock);

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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
/*
 * cpu_policy_rwsem is a per CPU reader-writer semaphore designed to cure
 * all cpufreq/hotplug/workqueue/etc related lock issues.
 *
 * The rules for this semaphore:
 * - Any routine that wants to read from the policy structure will
 *   do a down_read on this semaphore.
 * - Any routine that will write to the policy structure and/or may take away
 *   the policy altogether (eg. CPU hotplug), will hold this lock in write
 *   mode before doing so.
 *
 * Additional rules:
 * - All holders of the lock should check to make sure that the CPU they
 *   are concerned with are online after they get the lock.
 * - Governor routines that can be called in cpufreq hotplug path should not
 *   take this sem as top level hotplug notifier handler takes this.
 */
static DEFINE_PER_CPU(int, policy_cpu);
static DEFINE_PER_CPU(struct rw_semaphore, cpu_policy_rwsem);

#define lock_policy_rwsem(mode, cpu)					\
int lock_policy_rwsem_##mode						\
(int cpu)								\
{									\
	int policy_cpu = per_cpu(policy_cpu, cpu);			\
	BUG_ON(policy_cpu == -1);					\
	down_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu));		\
	if (unlikely(!cpu_online(cpu))) {				\
		up_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu));	\
		return -1;						\
	}								\
									\
	return 0;							\
}

lock_policy_rwsem(read, cpu);
EXPORT_SYMBOL_GPL(lock_policy_rwsem_read);

lock_policy_rwsem(write, cpu);
EXPORT_SYMBOL_GPL(lock_policy_rwsem_write);

void unlock_policy_rwsem_read(int cpu)
{
	int policy_cpu = per_cpu(policy_cpu, cpu);
	BUG_ON(policy_cpu == -1);
	up_read(&per_cpu(cpu_policy_rwsem, policy_cpu));
}
EXPORT_SYMBOL_GPL(unlock_policy_rwsem_read);

void unlock_policy_rwsem_write(int cpu)
{
	int policy_cpu = per_cpu(policy_cpu, cpu);
	BUG_ON(policy_cpu == -1);
	up_write(&per_cpu(cpu_policy_rwsem, policy_cpu));
}
EXPORT_SYMBOL_GPL(unlock_policy_rwsem_write);


Linus Torvalds's avatar
Linus Torvalds committed
106
/* internal prototypes */
107
108
static int __cpufreq_governor(struct cpufreq_policy *policy,
		unsigned int event);
109
static unsigned int __cpufreq_get(unsigned int cpu);
110
static void handle_update(struct work_struct *work);
Linus Torvalds's avatar
Linus Torvalds committed
111
112

/**
113
114
 * 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
115
116
117
118
 * "transition" list for kernel code that needs to handle
 * changes to devices when the CPU clock speed changes.
 * The mutex locks both lists.
 */
119
static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
120
static struct srcu_notifier_head cpufreq_transition_notifier_list;
Linus Torvalds's avatar
Linus Torvalds committed
121

122
static bool init_cpufreq_transition_notifier_list_called;
123
124
125
static int __init init_cpufreq_transition_notifier_list(void)
{
	srcu_init_notifier_head(&cpufreq_transition_notifier_list);
126
	init_cpufreq_transition_notifier_list_called = true;
127
128
	return 0;
}
129
pure_initcall(init_cpufreq_transition_notifier_list);
Linus Torvalds's avatar
Linus Torvalds committed
130
131

static LIST_HEAD(cpufreq_governor_list);
132
static DEFINE_MUTEX(cpufreq_governor_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
133

134
struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
Linus Torvalds's avatar
Linus Torvalds committed
135
136
137
138
{
	struct cpufreq_policy *data;
	unsigned long flags;

139
	if (cpu >= nr_cpu_ids)
Linus Torvalds's avatar
Linus Torvalds committed
140
141
142
143
144
145
146
147
148
149
150
151
152
		goto err_out;

	/* get the cpufreq driver */
	spin_lock_irqsave(&cpufreq_driver_lock, flags);

	if (!cpufreq_driver)
		goto err_out_unlock;

	if (!try_module_get(cpufreq_driver->owner))
		goto err_out_unlock;


	/* get the CPU */
153
	data = per_cpu(cpufreq_cpu_data, cpu);
Linus Torvalds's avatar
Linus Torvalds committed
154
155
156
157
158
159
160
161
162
163

	if (!data)
		goto err_out_put_module;

	if (!kobject_get(&data->kobj))
		goto err_out_put_module;

	spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
	return data;

164
err_out_put_module:
Linus Torvalds's avatar
Linus Torvalds committed
165
	module_put(cpufreq_driver->owner);
166
err_out_unlock:
Linus Torvalds's avatar
Linus Torvalds committed
167
	spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
168
err_out:
Linus Torvalds's avatar
Linus Torvalds committed
169
170
171
172
	return NULL;
}
EXPORT_SYMBOL_GPL(cpufreq_cpu_get);

173

Linus Torvalds's avatar
Linus Torvalds committed
174
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
void cpufreq_cpu_put(struct cpufreq_policy *data)
{
	kobject_put(&data->kobj);
	module_put(cpufreq_driver->owner);
}
EXPORT_SYMBOL_GPL(cpufreq_cpu_put);


/*********************************************************************
 *                     UNIFIED DEBUG HELPERS                         *
 *********************************************************************/
#ifdef CONFIG_CPU_FREQ_DEBUG

/* what part(s) of the CPUfreq subsystem are debugged? */
static unsigned int debug;

/* is the debug output ratelimit'ed using printk_ratelimit? User can
 * set or modify this value.
 */
static unsigned int debug_ratelimit = 1;

/* is the printk_ratelimit'ing enabled? It's enabled after a successful
 * loading of a cpufreq driver, temporarily disabled when a new policy
 * is set, and disabled upon cpufreq driver removal
 */
static unsigned int disable_ratelimit = 1;
static DEFINE_SPINLOCK(disable_ratelimit_lock);

202
static void cpufreq_debug_enable_ratelimit(void)
Linus Torvalds's avatar
Linus Torvalds committed
203
204
205
206
207
208
209
210
211
{
	unsigned long flags;

	spin_lock_irqsave(&disable_ratelimit_lock, flags);
	if (disable_ratelimit)
		disable_ratelimit--;
	spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
}

212
static void cpufreq_debug_disable_ratelimit(void)
Linus Torvalds's avatar
Linus Torvalds committed
213
214
215
216
217
218
219
220
{
	unsigned long flags;

	spin_lock_irqsave(&disable_ratelimit_lock, flags);
	disable_ratelimit++;
	spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
}

221
void cpufreq_debug_printk(unsigned int type, const char *prefix,
Dave Jones's avatar
Dave Jones committed
222
			const char *fmt, ...)
Linus Torvalds's avatar
Linus Torvalds committed
223
224
225
226
227
{
	char s[256];
	va_list args;
	unsigned int len;
	unsigned long flags;
228

Linus Torvalds's avatar
Linus Torvalds committed
229
230
231
	WARN_ON(!prefix);
	if (type & debug) {
		spin_lock_irqsave(&disable_ratelimit_lock, flags);
232
233
		if (!disable_ratelimit && debug_ratelimit
					&& !printk_ratelimit()) {
Linus Torvalds's avatar
Linus Torvalds committed
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
			spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
			return;
		}
		spin_unlock_irqrestore(&disable_ratelimit_lock, flags);

		len = snprintf(s, 256, KERN_DEBUG "%s: ", prefix);

		va_start(args, fmt);
		len += vsnprintf(&s[len], (256 - len), fmt, args);
		va_end(args);

		printk(s);

		WARN_ON(len < 5);
	}
}
EXPORT_SYMBOL(cpufreq_debug_printk);


module_param(debug, uint, 0644);
254
255
MODULE_PARM_DESC(debug, "CPUfreq debugging: add 1 to debug core,"
			" 2 to debug drivers, and 4 to debug governors.");
Linus Torvalds's avatar
Linus Torvalds committed
256
257

module_param(debug_ratelimit, uint, 0644);
258
259
MODULE_PARM_DESC(debug_ratelimit, "CPUfreq debugging:"
					" set to 0 to disable ratelimiting.");
Linus Torvalds's avatar
Linus Torvalds committed
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277

#else /* !CONFIG_CPU_FREQ_DEBUG */

static inline void cpufreq_debug_enable_ratelimit(void) { return; }
static inline void cpufreq_debug_disable_ratelimit(void) { return; }

#endif /* CONFIG_CPU_FREQ_DEBUG */


/*********************************************************************
 *            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
278
 * systems as each CPU might be scaled differently. So, use the arch
Linus Torvalds's avatar
Linus Torvalds committed
279
280
281
282
283
284
 * per-CPU loops_per_jiffy value wherever possible.
 */
#ifndef CONFIG_SMP
static unsigned long l_p_j_ref;
static unsigned int  l_p_j_ref_freq;

285
static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
Linus Torvalds's avatar
Linus Torvalds committed
286
287
288
289
290
291
292
{
	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;
293
		dprintk("saving %lu as reference value for loops_per_jiffy; "
294
			"freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
Linus Torvalds's avatar
Linus Torvalds committed
295
296
297
	}
	if ((val == CPUFREQ_PRECHANGE  && ci->old < ci->new) ||
	    (val == CPUFREQ_POSTCHANGE && ci->old > ci->new) ||
298
	    (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
299
300
		loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
								ci->new);
301
		dprintk("scaling loops_per_jiffy to %lu "
302
			"for frequency %u kHz\n", loops_per_jiffy, ci->new);
Linus Torvalds's avatar
Linus Torvalds committed
303
304
305
	}
}
#else
306
307
308
309
static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
{
	return;
}
Linus Torvalds's avatar
Linus Torvalds committed
310
311
312
313
#endif


/**
314
315
 * cpufreq_notify_transition - call notifier chain and adjust_jiffies
 * on frequency transition.
Linus Torvalds's avatar
Linus Torvalds committed
316
 *
317
318
 * This function calls the transition notifiers and the "adjust_jiffies"
 * function. It is called twice on all CPU frequency changes that have
319
 * external effects.
Linus Torvalds's avatar
Linus Torvalds committed
320
321
322
 */
void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
{
323
324
	struct cpufreq_policy *policy;

Linus Torvalds's avatar
Linus Torvalds committed
325
326
327
	BUG_ON(irqs_disabled());

	freqs->flags = cpufreq_driver->flags;
328
329
	dprintk("notification %u of frequency transition to %u kHz\n",
		state, freqs->new);
Linus Torvalds's avatar
Linus Torvalds committed
330

331
	policy = per_cpu(cpufreq_cpu_data, freqs->cpu);
Linus Torvalds's avatar
Linus Torvalds committed
332
	switch (state) {
333

Linus Torvalds's avatar
Linus Torvalds committed
334
	case CPUFREQ_PRECHANGE:
335
		/* detect if the driver reported a value as "old frequency"
336
337
		 * which is not equal to what the cpufreq core thinks is
		 * "old frequency".
Linus Torvalds's avatar
Linus Torvalds committed
338
339
		 */
		if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
340
341
			if ((policy) && (policy->cpu == freqs->cpu) &&
			    (policy->cur) && (policy->cur != freqs->old)) {
342
				dprintk("Warning: CPU frequency is"
343
344
345
					" %u, cpufreq assumed %u kHz.\n",
					freqs->old, policy->cur);
				freqs->old = policy->cur;
Linus Torvalds's avatar
Linus Torvalds committed
346
347
			}
		}
348
		srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
349
				CPUFREQ_PRECHANGE, freqs);
Linus Torvalds's avatar
Linus Torvalds committed
350
351
		adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
		break;
352

Linus Torvalds's avatar
Linus Torvalds committed
353
354
	case CPUFREQ_POSTCHANGE:
		adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
355
		srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
356
				CPUFREQ_POSTCHANGE, freqs);
357
358
		if (likely(policy) && likely(policy->cpu == freqs->cpu))
			policy->cur = freqs->new;
Linus Torvalds's avatar
Linus Torvalds committed
359
360
361
362
363
364
365
366
367
368
369
		break;
	}
}
EXPORT_SYMBOL_GPL(cpufreq_notify_transition);



/*********************************************************************
 *                          SYSFS INTERFACE                          *
 *********************************************************************/

370
371
372
373
374
static struct cpufreq_governor *__find_governor(const char *str_governor)
{
	struct cpufreq_governor *t;

	list_for_each_entry(t, &cpufreq_governor_list, governor_list)
375
		if (!strnicmp(str_governor, t->name, CPUFREQ_NAME_LEN))
376
377
378
379
380
			return t;

	return NULL;
}

Linus Torvalds's avatar
Linus Torvalds committed
381
382
383
/**
 * cpufreq_parse_governor - parse a governor string
 */
Dave Jones's avatar
Dave Jones committed
384
static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
Linus Torvalds's avatar
Linus Torvalds committed
385
386
				struct cpufreq_governor **governor)
{
387
388
	int err = -EINVAL;

Linus Torvalds's avatar
Linus Torvalds committed
389
	if (!cpufreq_driver)
390
391
		goto out;

Linus Torvalds's avatar
Linus Torvalds committed
392
393
394
	if (cpufreq_driver->setpolicy) {
		if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
			*policy = CPUFREQ_POLICY_PERFORMANCE;
395
			err = 0;
396
397
		} else if (!strnicmp(str_governor, "powersave",
						CPUFREQ_NAME_LEN)) {
Linus Torvalds's avatar
Linus Torvalds committed
398
			*policy = CPUFREQ_POLICY_POWERSAVE;
399
			err = 0;
Linus Torvalds's avatar
Linus Torvalds committed
400
		}
401
	} else if (cpufreq_driver->target) {
Linus Torvalds's avatar
Linus Torvalds committed
402
		struct cpufreq_governor *t;
403

404
		mutex_lock(&cpufreq_governor_mutex);
405
406
407

		t = __find_governor(str_governor);

408
		if (t == NULL) {
409
410
			char *name = kasprintf(GFP_KERNEL, "cpufreq_%s",
								str_governor);
411
412
413
414
415

			if (name) {
				int ret;

				mutex_unlock(&cpufreq_governor_mutex);
416
				ret = request_module("%s", name);
417
418
419
420
421
422
423
424
425
				mutex_lock(&cpufreq_governor_mutex);

				if (ret == 0)
					t = __find_governor(str_governor);
			}

			kfree(name);
		}

426
427
428
		if (t != NULL) {
			*governor = t;
			err = 0;
Linus Torvalds's avatar
Linus Torvalds committed
429
		}
430

431
		mutex_unlock(&cpufreq_governor_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
432
	}
433
out:
434
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
435
436
437
438
}


/**
439
440
 * cpufreq_per_cpu_attr_read() / show_##file_name() -
 * print out cpufreq information
Linus Torvalds's avatar
Linus Torvalds committed
441
442
443
444
445
 *
 * Write out information from cpufreq_driver->policy[cpu]; object must be
 * "unsigned int".
 */

446
447
#define show_one(file_name, object)			\
static ssize_t show_##file_name				\
Dave Jones's avatar
Dave Jones committed
448
(struct cpufreq_policy *policy, char *buf)		\
449
{							\
450
	return sprintf(buf, "%u\n", policy->object);	\
Linus Torvalds's avatar
Linus Torvalds committed
451
452
453
454
}

show_one(cpuinfo_min_freq, cpuinfo.min_freq);
show_one(cpuinfo_max_freq, cpuinfo.max_freq);
455
show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
Linus Torvalds's avatar
Linus Torvalds committed
456
457
458
459
show_one(scaling_min_freq, min);
show_one(scaling_max_freq, max);
show_one(scaling_cur_freq, cur);

460
461
static int __cpufreq_set_policy(struct cpufreq_policy *data,
				struct cpufreq_policy *policy);
462

Linus Torvalds's avatar
Linus Torvalds committed
463
464
465
466
467
/**
 * 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
468
(struct cpufreq_policy *policy, const char *buf, size_t count)		\
Linus Torvalds's avatar
Linus Torvalds committed
469
470
471
472
473
474
475
476
{									\
	unsigned int ret = -EINVAL;					\
	struct cpufreq_policy new_policy;				\
									\
	ret = cpufreq_get_policy(&new_policy, policy->cpu);		\
	if (ret)							\
		return -EINVAL;						\
									\
477
	ret = sscanf(buf, "%u", &new_policy.object);			\
Linus Torvalds's avatar
Linus Torvalds committed
478
479
480
	if (ret != 1)							\
		return -EINVAL;						\
									\
481
482
	ret = __cpufreq_set_policy(policy, &new_policy);		\
	policy->user_policy.object = policy->object;			\
Linus Torvalds's avatar
Linus Torvalds committed
483
484
485
486
									\
	return ret ? ret : count;					\
}

487
488
store_one(scaling_min_freq, min);
store_one(scaling_max_freq, max);
Linus Torvalds's avatar
Linus Torvalds committed
489
490
491
492

/**
 * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
 */
Dave Jones's avatar
Dave Jones committed
493
494
static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
					char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
495
{
496
	unsigned int cur_freq = __cpufreq_get(policy->cpu);
Linus Torvalds's avatar
Linus Torvalds committed
497
498
499
500
501
502
503
504
505
	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
506
static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
507
{
508
	if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
Linus Torvalds's avatar
Linus Torvalds committed
509
510
511
512
		return sprintf(buf, "powersave\n");
	else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
		return sprintf(buf, "performance\n");
	else if (policy->governor)
513
514
		return scnprintf(buf, CPUFREQ_NAME_LEN, "%s\n",
				policy->governor->name);
Linus Torvalds's avatar
Linus Torvalds committed
515
516
517
518
519
520
521
	return -EINVAL;
}


/**
 * store_scaling_governor - store policy for the specified CPU
 */
Dave Jones's avatar
Dave Jones committed
522
523
static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
					const char *buf, size_t count)
Linus Torvalds's avatar
Linus Torvalds committed
524
525
526
527
528
529
530
531
532
{
	unsigned int ret = -EINVAL;
	char	str_governor[16];
	struct cpufreq_policy new_policy;

	ret = cpufreq_get_policy(&new_policy, policy->cpu);
	if (ret)
		return ret;

533
	ret = sscanf(buf, "%15s", str_governor);
Linus Torvalds's avatar
Linus Torvalds committed
534
535
536
	if (ret != 1)
		return -EINVAL;

537
538
	if (cpufreq_parse_governor(str_governor, &new_policy.policy,
						&new_policy.governor))
Linus Torvalds's avatar
Linus Torvalds committed
539
540
		return -EINVAL;

541
542
543
544
545
546
547
	/* Do not use cpufreq_set_policy here or the user_policy.max
	   will be wrongly overridden */
	ret = __cpufreq_set_policy(policy, &new_policy);

	policy->user_policy.policy = policy->policy;
	policy->user_policy.governor = policy->governor;

548
549
550
551
	if (ret)
		return ret;
	else
		return count;
Linus Torvalds's avatar
Linus Torvalds committed
552
553
554
555
556
}

/**
 * show_scaling_driver - show the cpufreq driver currently loaded
 */
Dave Jones's avatar
Dave Jones committed
557
static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
558
559
560
561
562
563
564
{
	return scnprintf(buf, CPUFREQ_NAME_LEN, "%s\n", cpufreq_driver->name);
}

/**
 * show_scaling_available_governors - show the available CPUfreq governors
 */
Dave Jones's avatar
Dave Jones committed
565
566
static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
						char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
567
568
569
570
571
572
573
574
575
576
{
	ssize_t i = 0;
	struct cpufreq_governor *t;

	if (!cpufreq_driver->target) {
		i += sprintf(buf, "performance powersave");
		goto out;
	}

	list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
577
578
		if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
		    - (CPUFREQ_NAME_LEN + 2)))
Linus Torvalds's avatar
Linus Torvalds committed
579
580
581
			goto out;
		i += scnprintf(&buf[i], CPUFREQ_NAME_LEN, "%s ", t->name);
	}
582
out:
Linus Torvalds's avatar
Linus Torvalds committed
583
584
585
	i += sprintf(&buf[i], "\n");
	return i;
}
586

587
static ssize_t show_cpus(const struct cpumask *mask, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
588
589
590
591
{
	ssize_t i = 0;
	unsigned int cpu;

592
	for_each_cpu(cpu, mask) {
Linus Torvalds's avatar
Linus Torvalds committed
593
594
595
596
		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))
597
			break;
Linus Torvalds's avatar
Linus Torvalds committed
598
599
600
601
602
	}
	i += sprintf(&buf[i], "\n");
	return i;
}

603
604
605
606
607
608
/**
 * 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)
{
609
	if (cpumask_empty(policy->related_cpus))
610
611
612
613
614
615
616
617
618
619
620
621
		return show_cpus(policy->cpus, buf);
	return show_cpus(policy->related_cpus, buf);
}

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

622
static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
Dave Jones's avatar
Dave Jones committed
623
					const char *buf, size_t count)
624
625
626
627
{
	unsigned int freq = 0;
	unsigned int ret;

628
	if (!policy->governor || !policy->governor->store_setspeed)
629
630
631
632
633
634
635
636
637
638
639
640
641
		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)
{
642
	if (!policy->governor || !policy->governor->show_setspeed)
643
644
645
646
		return sprintf(buf, "<unsupported>\n");

	return policy->governor->show_setspeed(policy, buf);
}
Linus Torvalds's avatar
Linus Torvalds committed
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662

#define define_one_ro(_name) \
static struct freq_attr _name = \
__ATTR(_name, 0444, show_##_name, NULL)

#define define_one_ro0400(_name) \
static struct freq_attr _name = \
__ATTR(_name, 0400, show_##_name, NULL)

#define define_one_rw(_name) \
static struct freq_attr _name = \
__ATTR(_name, 0644, show_##_name, store_##_name)

define_one_ro0400(cpuinfo_cur_freq);
define_one_ro(cpuinfo_min_freq);
define_one_ro(cpuinfo_max_freq);
663
define_one_ro(cpuinfo_transition_latency);
Linus Torvalds's avatar
Linus Torvalds committed
664
665
666
define_one_ro(scaling_available_governors);
define_one_ro(scaling_driver);
define_one_ro(scaling_cur_freq);
667
define_one_ro(related_cpus);
Linus Torvalds's avatar
Linus Torvalds committed
668
669
670
671
define_one_ro(affected_cpus);
define_one_rw(scaling_min_freq);
define_one_rw(scaling_max_freq);
define_one_rw(scaling_governor);
672
define_one_rw(scaling_setspeed);
Linus Torvalds's avatar
Linus Torvalds committed
673

Dave Jones's avatar
Dave Jones committed
674
static struct attribute *default_attrs[] = {
Linus Torvalds's avatar
Linus Torvalds committed
675
676
	&cpuinfo_min_freq.attr,
	&cpuinfo_max_freq.attr,
677
	&cpuinfo_transition_latency.attr,
Linus Torvalds's avatar
Linus Torvalds committed
678
679
680
	&scaling_min_freq.attr,
	&scaling_max_freq.attr,
	&affected_cpus.attr,
681
	&related_cpus.attr,
Linus Torvalds's avatar
Linus Torvalds committed
682
683
684
	&scaling_governor.attr,
	&scaling_driver.attr,
	&scaling_available_governors.attr,
685
	&scaling_setspeed.attr,
Linus Torvalds's avatar
Linus Torvalds committed
686
687
688
	NULL
};

689
690
#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
691

692
static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
693
{
Dave Jones's avatar
Dave Jones committed
694
695
	struct cpufreq_policy *policy = to_policy(kobj);
	struct freq_attr *fattr = to_attr(attr);
696
	ssize_t ret = -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
697
698
	policy = cpufreq_cpu_get(policy->cpu);
	if (!policy)
699
		goto no_policy;
700
701

	if (lock_policy_rwsem_read(policy->cpu) < 0)
702
		goto fail;
703

704
705
706
707
708
	if (fattr->show)
		ret = fattr->show(policy, buf);
	else
		ret = -EIO;

709
	unlock_policy_rwsem_read(policy->cpu);
710
fail:
Linus Torvalds's avatar
Linus Torvalds committed
711
	cpufreq_cpu_put(policy);
712
no_policy:
Linus Torvalds's avatar
Linus Torvalds committed
713
714
715
	return ret;
}

Dave Jones's avatar
Dave Jones committed
716
717
static ssize_t store(struct kobject *kobj, struct attribute *attr,
		     const char *buf, size_t count)
Linus Torvalds's avatar
Linus Torvalds committed
718
{
Dave Jones's avatar
Dave Jones committed
719
720
	struct cpufreq_policy *policy = to_policy(kobj);
	struct freq_attr *fattr = to_attr(attr);
721
	ssize_t ret = -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
722
723
	policy = cpufreq_cpu_get(policy->cpu);
	if (!policy)
724
		goto no_policy;
725
726

	if (lock_policy_rwsem_write(policy->cpu) < 0)
727
		goto fail;
728

729
730
731
732
733
	if (fattr->store)
		ret = fattr->store(policy, buf, count);
	else
		ret = -EIO;

734
	unlock_policy_rwsem_write(policy->cpu);
735
fail:
Linus Torvalds's avatar
Linus Torvalds committed
736
	cpufreq_cpu_put(policy);
737
no_policy:
Linus Torvalds's avatar
Linus Torvalds committed
738
739
740
	return ret;
}

Dave Jones's avatar
Dave Jones committed
741
static void cpufreq_sysfs_release(struct kobject *kobj)
Linus Torvalds's avatar
Linus Torvalds committed
742
{
Dave Jones's avatar
Dave Jones committed
743
	struct cpufreq_policy *policy = to_policy(kobj);
Linus Torvalds's avatar
Linus Torvalds committed
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
	dprintk("last reference is dropped\n");
	complete(&policy->kobj_unregister);
}

static struct sysfs_ops sysfs_ops = {
	.show	= show,
	.store	= store,
};

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


/**
 * cpufreq_add_dev - add a CPU device
 *
763
 * Adds the cpufreq interface for a CPU device.
Linus Torvalds's avatar
Linus Torvalds committed
764
 */
Dave Jones's avatar
Dave Jones committed
765
static int cpufreq_add_dev(struct sys_device *sys_dev)
Linus Torvalds's avatar
Linus Torvalds committed
766
767
768
769
770
771
{
	unsigned int cpu = sys_dev->id;
	int ret = 0;
	struct cpufreq_policy new_policy;
	struct cpufreq_policy *policy;
	struct freq_attr **drv_attr;
772
	struct sys_device *cpu_sys_dev;
Linus Torvalds's avatar
Linus Torvalds committed
773
774
	unsigned long flags;
	unsigned int j;
775
776
777
#ifdef CONFIG_SMP
	struct cpufreq_policy *managed_policy;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
778

779
780
781
	if (cpu_is_offline(cpu))
		return 0;

Linus Torvalds's avatar
Linus Torvalds committed
782
783
784
785
786
787
788
789
	cpufreq_debug_disable_ratelimit();
	dprintk("adding CPU %u\n", cpu);

#ifdef CONFIG_SMP
	/* check whether a different CPU already registered this
	 * CPU because it is in the same boat. */
	policy = cpufreq_cpu_get(cpu);
	if (unlikely(policy)) {
790
		cpufreq_cpu_put(policy);
Linus Torvalds's avatar
Linus Torvalds committed
791
792
793
794
795
796
797
798
799
800
		cpufreq_debug_enable_ratelimit();
		return 0;
	}
#endif

	if (!try_module_get(cpufreq_driver->owner)) {
		ret = -EINVAL;
		goto module_out;
	}

801
	policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
802
803
804
805
	if (!policy) {
		ret = -ENOMEM;
		goto nomem_out;
	}
806
807
808
809
810
	if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL)) {
		kfree(policy);
		ret = -ENOMEM;
		goto nomem_out;
	}
811
	if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL)) {
812
813
814
815
816
		free_cpumask_var(policy->cpus);
		kfree(policy);
		ret = -ENOMEM;
		goto nomem_out;
	}
Linus Torvalds's avatar
Linus Torvalds committed
817
818

	policy->cpu = cpu;
819
	cpumask_copy(policy->cpus, cpumask_of(cpu));
Linus Torvalds's avatar
Linus Torvalds committed
820

821
822
823
824
	/* Initially set CPU itself as the policy_cpu */
	per_cpu(policy_cpu, cpu) = cpu;
	lock_policy_rwsem_write(cpu);

Linus Torvalds's avatar
Linus Torvalds committed
825
	init_completion(&policy->kobj_unregister);
826
	INIT_WORK(&policy->update, handle_update);
Linus Torvalds's avatar
Linus Torvalds committed
827

828
829
	/* Set governor before ->init, so that driver could check it */
	policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
Linus Torvalds's avatar
Linus Torvalds committed
830
831
832
833
834
835
836
837
	/* call driver. From then on the cpufreq must be able
	 * to accept all calls to ->verify and ->setpolicy for this CPU
	 */
	ret = cpufreq_driver->init(policy);
	if (ret) {
		dprintk("initialization failed\n");
		goto err_out;
	}
838
839
	policy->user_policy.min = policy->min;
	policy->user_policy.max = policy->max;
Linus Torvalds's avatar
Linus Torvalds committed
840

841
842
843
	blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
				     CPUFREQ_START, policy);

844
#ifdef CONFIG_SMP
845
846

#ifdef CONFIG_HOTPLUG_CPU
847
848
	if (per_cpu(cpufreq_cpu_governor, cpu)) {
		policy->governor = per_cpu(cpufreq_cpu_governor, cpu);
849
850
851
852
853
		dprintk("Restoring governor %s for cpu %d\n",
		       policy->governor->name, cpu);
	}
#endif

854
	for_each_cpu(j, policy->cpus) {
855
856
857
		if (cpu == j)
			continue;

858
859
		/* Check for existing affected CPUs.
		 * They may not be aware of it due to CPU Hotplug.
860
		 */
861
		managed_policy = cpufreq_cpu_get(j);		/* FIXME: Where is this released?  What about error paths? */
862
		if (unlikely(managed_policy)) {
863
864
865
866
867
868
869
870

			/* Set proper policy_cpu */
			unlock_policy_rwsem_write(cpu);
			per_cpu(policy_cpu, cpu) = managed_policy->cpu;

			if (lock_policy_rwsem_write(cpu) < 0)
				goto err_out_driver_exit;

871
			spin_lock_irqsave(&cpufreq_driver_lock, flags);
872
			cpumask_copy(managed_policy->cpus, policy->cpus);
873
			per_cpu(cpufreq_cpu_data, cpu) = managed_policy;
874
875
876
			spin_unlock_irqrestore(&cpufreq_driver_lock, flags);

			dprintk("CPU already managed, adding link\n");
877
878
879
			ret = sysfs_create_link(&sys_dev->kobj,
						&managed_policy->kobj,
						"cpufreq");
880
			if (ret)
881
				goto err_out_driver_exit;
882
883
884
885
886
887
888

			cpufreq_debug_enable_ratelimit();
			ret = 0;
			goto err_out_driver_exit; /* call driver->exit() */
		}
	}
#endif
Linus Torvalds's avatar
Linus Torvalds committed
889
890
891
	memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));

	/* prepare interface data */
892
893
894
895
896
897
898
899
900
	ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq, &sys_dev->kobj,
				   "cpufreq");
	if (ret)
		goto err_out_driver_exit;

	/* set up files for this cpu device */
	drv_attr = cpufreq_driver->attr;
	while ((drv_attr) && (*drv_attr)) {
		ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
901
		if (ret)
902
			goto err_out_driver_exit;
903
904
905
906
907
908
909
910
911
		drv_attr++;
	}
	if (cpufreq_driver->get) {
		ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
		if (ret)
			goto err_out_driver_exit;
	}
	if (cpufreq_driver->target) {
		ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
912
		if (ret)
913
914
			goto err_out_driver_exit;
	}
Linus Torvalds's avatar
Linus Torvalds committed
915
916

	spin_lock_irqsave(&cpufreq_driver_lock, flags);
917
	for_each_cpu(j, policy->cpus) {
918
		per_cpu(cpufreq_cpu_data, j) = policy;
919
920
		per_cpu(policy_cpu, j) = policy->cpu;
	}
Linus Torvalds's avatar
Linus Torvalds committed
921
	spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
922
923

	/* symlink affected CPUs */
924
	for_each_cpu(j, policy->cpus) {
925
926
927
928
929
		if (j == cpu)
			continue;
		if (!cpu_online(j))
			continue;

930
		dprintk("CPU %u already managed, adding link\n", j);
931
932
		cpufreq_cpu_get(cpu);
		cpu_sys_dev = get_cpu_sysdev(j);
933
934
		ret = sysfs_create_link(&cpu_sys_dev->kobj, &policy->kobj,
					"cpufreq");
935
		if (ret)
936
			goto err_out_unregister;
937
938
	}

Linus Torvalds's avatar
Linus Torvalds committed
939
940
	policy->governor = NULL; /* to assure that the starting sequence is
				  * run in cpufreq_set_policy */
941

Linus Torvalds's avatar
Linus Torvalds committed
942
	/* set default policy */
943
944
	ret = __cpufreq_set_policy(policy, &new_policy);
	policy->user_policy.policy = policy->policy;
945
	policy->user_policy.governor = policy->governor;
946

Linus Torvalds's avatar
Linus Torvalds committed
947
948
949
950
951
	if (ret) {
		dprintk("setting policy failed\n");
		goto err_out_unregister;
	}

952
953
	unlock_policy_rwsem_write(cpu);

954
	kobject_uevent(&policy->kobj, KOBJ_ADD);
Linus Torvalds's avatar
Linus Torvalds committed
955
956
957
	module_put(cpufreq_driver->owner);
	dprintk("initialization complete\n");
	cpufreq_debug_enable_ratelimit();
958

Linus Torvalds's avatar
Linus Torvalds committed
959
960
961
962
963
	return 0;


err_out_unregister:
	spin_lock_irqsave(&cpufreq_driver_lock, flags);
964
	for_each_cpu(j, policy->cpus)
965
		per_cpu(cpufreq_cpu_data, j) = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
966
967
	spin_unlock_irqrestore(&cpufreq_driver_lock, flags);

968
	kobject_put(&policy->kobj);
Linus Torvalds's avatar
Linus Torvalds committed
969
970
	wait_for_completion(&policy->kobj_unregister);

971
972
973
974
err_out_driver_exit:
	if (cpufreq_driver->exit)
		cpufreq_driver->exit(policy);

Linus Torvalds's avatar
Linus Torvalds committed
975
err_out:
976
	unlock_policy_rwsem_write(cpu);
Linus Torvalds's avatar
Linus Torvalds committed
977
978
979
980
	kfree(policy);

nomem_out:
	module_put(cpufreq_driver->owner);
981
module_out:
Linus Torvalds's avatar
Linus Torvalds committed
982
983
984
985
986
987
	cpufreq_debug_enable_ratelimit();
	return ret;
}


/**
988
 * __cpufreq_remove_dev - remove a CPU device
Linus Torvalds's avatar
Linus Torvalds committed
989
990
 *
 * Removes the cpufreq interface for a CPU device.
991
992
 * Caller should already have policy_rwsem in write mode for this CPU.
 * This routine frees the rwsem before returning.
Linus Torvalds's avatar
Linus Torvalds committed
993
 */
Dave Jones's avatar
Dave Jones committed
994
static int __cpufreq_remove_dev(struct sys_device *sys_dev)
Linus Torvalds's avatar
Linus Torvalds committed
995
996
997
998
999
{
	unsigned int cpu = sys_dev->id;
	unsigned long flags;
	struct cpufreq_policy *data;
#ifdef CONFIG_SMP
1000
	struct sys_device *cpu_sys_dev;
Linus Torvalds's avatar
Linus Torvalds committed
1001
1002
1003
1004
1005
1006
1007
	unsigned int j;
#endif

	cpufreq_debug_disable_ratelimit();
	dprintk("unregistering CPU %u\n", cpu);

	spin_lock_irqsave(&cpufreq_driver_lock, flags);
1008
	data = per_cpu(cpufreq_cpu_data, cpu);
Linus Torvalds's avatar
Linus Torvalds committed
1009
1010
1011
1012

	if (!data) {
		spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
		cpufreq_debug_enable_ratelimit();
1013
		unlock_policy_rwsem_write(cpu);
Linus Torvalds's avatar
Linus Torvalds committed
1014
1015
		return -EINVAL;
	}
1016
	per_cpu(cpufreq_cpu_data, cpu) = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1017
1018
1019
1020


#ifdef CONFIG_SMP
	/* if this isn't the CPU which is the parent of the kobj, we
1021
	 * only need to unlink, put and exit
Linus Torvalds's avatar
Linus Torvalds committed
1022
1023
1024
	 */
	if (unlikely(cpu != data->cpu)) {
		dprintk("removing link\n");
1025
		cpumask_clear_cpu(cpu, data->cpus);
Linus Torvalds's avatar
Linus Torvalds committed
1026
1027
1028
1029
		spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
		sysfs_remove_link(&sys_dev->kobj, "cpufreq");
		cpufreq_cpu_put(data);
		cpufreq_debug_enable_ratelimit();
1030
		unlock_policy_rwsem_write(cpu);
Linus Torvalds's avatar
Linus Torvalds committed
1031
1032
1033
1034
1035
		return 0;
	}
#endif

#ifdef CONFIG_SMP
1036
1037

#ifdef CONFIG_HOTPLUG_CPU
1038
	per_cpu(cpufreq_cpu_governor, cpu) = data->governor;
1039
1040
#endif

Linus Torvalds's avatar
Linus Torvalds committed
1041
1042
	/* if we have other CPUs still registered, we need to unlink them,
	 * or else wait_for_completion below will lock up. Clean the
1043
1044
	 * per_cpu(cpufreq_cpu_data) while holding the lock, and remove
	 * the sysfs links afterwards.
Linus Torvalds's avatar
Linus Torvalds committed
1045
	 */
1046
1047
	if (unlikely(cpumask_weight(data->cpus) > 1)) {
		for_each_cpu(j, data->cpus) {
Linus Torvalds's avatar
Linus Torvalds committed
1048
1049
			if (j == cpu)
				continue;
1050
			per_cpu(cpufreq_cpu_data, j) = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1051
1052
1053
1054
1055
		}
	}

	spin_unlock_irqrestore(&cpufreq_driver_lock, flags);

1056
1057
	if (unlikely(cpumask_weight(data->cpus) > 1)) {
		for_each_cpu(j, data->cpus) {
Linus Torvalds's avatar
Linus Torvalds committed
1058
1059
1060
			if (j == cpu)
				continue;
			dprintk("removing link for cpu %u\n", j);
1061
#ifdef CONFIG_HOTPLUG_CPU
1062
			per_cpu(cpufreq_cpu_governor, j) = data->governor;
1063
#endif
1064
1065
			cpu_sys_dev = get_cpu_sysdev(j);
			sysfs_remove_link(&cpu_sys_dev->kobj, "cpufreq");
Linus Torvalds's avatar
Linus Torvalds committed
1066
1067
1068
1069
1070
1071
1072
			cpufreq_cpu_put(data);
		}
	}
#else
	spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
#endif

1073
1074
	unlock_policy_rwsem_write(cpu);

Linus Torvalds's avatar
Linus Torvalds committed
1075
1076
	if (cpufreq_driver->target)
		__cpufreq_governor(data, CPUFREQ_GOV_STOP);
1077

Linus Torvalds's avatar
Linus Torvalds committed
1078
1079
1080
	kobject_put(&data->kobj);

	/* we need to make sure that the underlying kobj is actually
1081
	 * not referenced anymore by anybody before we proceed with
Linus Torvalds's avatar
Linus Torvalds committed
1082
1083
1084
1085
1086
1087
1088
1089
1090
	 * unloading.
	 */
	dprintk("waiting for dropping of refcount\n");
	wait_for_completion(&data->kobj_unregister);
	dprintk("wait complete\n");

	if (cpufreq_driver->exit)
		cpufreq_driver->exit(data);

1091
1092
	free_cpumask_var(data->related_cpus);
	free_cpumask_var(data->cpus);
Linus Torvalds's avatar
Linus Torvalds committed
1093
	kfree(data);
1094
	per_cpu(cpufreq_cpu_data, cpu) = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1095
1096
1097
1098
1099
1100

	cpufreq_debug_enable_ratelimit();
	return 0;
}


Dave Jones's avatar
Dave Jones committed
1101
static int cpufreq_remove_dev(struct sys_device *sys_dev)
1102
1103
1104
{
	unsigned int cpu = sys_dev->id;
	int retval;
1105
1106
1107
1108

	if (cpu_is_offline(cpu))
		return 0;

1109
1110
1111
1112
1113
1114
1115
1116
	if (unlikely(lock_policy_rwsem_write(cpu)))
		BUG();

	retval = __cpufreq_remove_dev(sys_dev);
	return retval;
}


1117
static void handle_update(struct work_struct *work)
Linus Torvalds's avatar
Linus Torvalds committed
1118
{
1119
1120
1121
	struct cpufreq_policy *policy =
		container_of(work, struct cpufreq_policy, update);
	unsigned int cpu = policy->cpu;
Linus Torvalds's avatar
Linus Torvalds committed
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
	dprintk("handle_update for cpu %u called\n", cpu);
	cpufreq_update_policy(cpu);
}

/**
 *	cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're in deep trouble.
 *	@cpu: cpu number
 *	@old_freq: CPU frequency the kernel thinks the CPU runs at
 *	@new_freq: CPU frequency the CPU actually runs at
 *
1132
1133
 *	We adjust to current frequency first, and need to clean up later.
 *	So either call to cpufreq_update_policy() or schedule handle_update()).
Linus Torvalds's avatar
Linus Torvalds committed
1134
 */
1135
1136
static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
				unsigned int new_freq)
Linus Torvalds's avatar
Linus Torvalds committed
1137
1138
1139
{
	struct cpufreq_freqs freqs;

1140
	dprintk("Warning: CPU frequency out of sync: cpufreq and timing "
Linus Torvalds's avatar
Linus Torvalds committed
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
	       "core thinks of %u, is %u kHz.\n", old_freq, new_freq);

	freqs.cpu = cpu;
	freqs.old = old_freq;
	freqs.new = new_freq;
	cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
	cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
}


1151
/**
1152
 * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
1153
1154
1155
1156
1157
1158
1159
1160
 * @cpu: CPU number
 *
 * This is the last known freq, without actually getting it from the driver.
 * Return value will be same as what is shown in scaling_cur_freq in sysfs.
 */
unsigned int cpufreq_quick_get(unsigned int cpu)
{
	struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1161
	unsigned int ret_freq = 0;
1162
1163

	if (policy) {
1164
		ret_freq = policy->cur;
1165
1166
1167
		cpufreq_cpu_put(policy);
	}

Dave Jones's avatar
Dave Jones committed
1168
	return ret_freq;
1169
1170
1171
1172
}
EXPORT_SYMBOL(cpufreq_quick_get);


1173
static unsigned int __cpufreq_get(unsigned int cpu)
Linus Torvalds's avatar
Linus Torvalds committed
1174
{
1175
	struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
1176
	unsigned int ret_freq = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1177
1178

	if (!cpufreq_driver->get)
Dave Jones's avatar
Dave Jones committed
1179
		return ret_freq;
Linus Torvalds's avatar
Linus Torvalds committed
1180

1181
	ret_freq = cpufreq_driver->get(cpu);
Linus Torvalds's avatar
Linus Torvalds committed
1182

1183
1184
1185
1186
1187
1188
	if (ret_freq && policy->cur &&
		!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
		/* verify no discrepancy between actual and
					saved value exists */
		if (unlikely(ret_freq != policy->cur)) {
			cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
Linus Torvalds's avatar
Linus Torvalds committed
1189
1190
1191
1192
			schedule_work(&policy->update);
		}
	}

Dave Jones's avatar
Dave Jones committed
1193
	return ret_freq;
1194
}
Linus Torvalds's avatar
Linus Torvalds committed
1195

1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
/**
 * cpufreq_get - get the current CPU frequency (in kHz)
 * @cpu: CPU number
 *
 * Get the CPU current (static) CPU frequency
 */
unsigned int cpufreq_get(unsigned int cpu)
{
	unsigned int ret_freq = 0;
	struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);

	if (!policy)
		goto out;

	if (unlikely(lock_policy_rwsem_read(cpu)))
		goto out_policy;<