cpufreq.c 50.4 KB
Newer Older
L
Linus Torvalds 已提交
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
 *
L
Linus Torvalds 已提交
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>
L
Linus Torvalds 已提交
31

32 33
#include <trace/events/power.h>

34 35
#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, \
						"cpufreq-core", msg)
L
Linus Torvalds 已提交
36 37

/**
D
Dave Jones 已提交
38
 * The "cpufreq driver" - the arch- or hardware-dependent low
L
Linus Torvalds 已提交
39 40 41
 * level driver of CPUFreq support, and its spinlock. This lock
 * also protects the cpufreq_cpu_data array.
 */
42
static struct cpufreq_driver *cpufreq_driver;
43
static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
44 45
#ifdef CONFIG_HOTPLUG_CPU
/* This one keeps track of the previously set governor of a removed CPU */
46
static DEFINE_PER_CPU(char[CPUFREQ_NAME_LEN], cpufreq_cpu_governor);
47
#endif
L
Linus Torvalds 已提交
48 49
static DEFINE_SPINLOCK(cpufreq_driver_lock);

50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
/*
 * 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.
66 67
 * - Lock should not be held across
 *     __cpufreq_governor(data, CPUFREQ_GOV_STOP);
68
 */
69
static DEFINE_PER_CPU(int, cpufreq_policy_cpu);
70 71 72
static DEFINE_PER_CPU(struct rw_semaphore, cpu_policy_rwsem);

#define lock_policy_rwsem(mode, cpu)					\
73
static int lock_policy_rwsem_##mode					\
74 75
(int cpu)								\
{									\
76
	int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu);		\
77 78 79 80 81 82 83 84 85 86 87 88 89 90
	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);

lock_policy_rwsem(write, cpu);

91
static void unlock_policy_rwsem_read(int cpu)
92
{
93
	int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu);
94 95 96 97
	BUG_ON(policy_cpu == -1);
	up_read(&per_cpu(cpu_policy_rwsem, policy_cpu));
}

98
static void unlock_policy_rwsem_write(int cpu)
99
{
100
	int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu);
101 102 103 104 105
	BUG_ON(policy_cpu == -1);
	up_write(&per_cpu(cpu_policy_rwsem, policy_cpu));
}


L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
111 112

/**
113 114
 * Two notifier lists: the "policy" list is involved in the
 * validation process for a new CPU frequency policy; the
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
130 131

static LIST_HEAD(cpufreq_governor_list);
132
static DEFINE_MUTEX(cpufreq_governor_mutex);
L
Linus Torvalds 已提交
133

134
struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
L
Linus Torvalds 已提交
135 136 137 138
{
	struct cpufreq_policy *data;
	unsigned long flags;

139
	if (cpu >= nr_cpu_ids)
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
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:
L
Linus Torvalds 已提交
165
	module_put(cpufreq_driver->owner);
166
err_out_unlock:
L
Linus Torvalds 已提交
167
	spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
168
err_out:
L
Linus Torvalds 已提交
169 170 171 172
	return NULL;
}
EXPORT_SYMBOL_GPL(cpufreq_cpu_get);

173

L
Linus Torvalds 已提交
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)
L
Linus Torvalds 已提交
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)
L
Linus Torvalds 已提交
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,
D
Dave Jones 已提交
222
			const char *fmt, ...)
L
Linus Torvalds 已提交
223 224 225 226 227
{
	char s[256];
	va_list args;
	unsigned int len;
	unsigned long flags;
228

L
Linus Torvalds 已提交
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()) {
L
Linus Torvalds 已提交
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.");
L
Linus Torvalds 已提交
256 257

module_param(debug_ratelimit, uint, 0644);
258 259
MODULE_PARM_DESC(debug_ratelimit, "CPUfreq debugging:"
					" set to 0 to disable ratelimiting.");
L
Linus Torvalds 已提交
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
L
Linus Torvalds 已提交
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)
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
303 304 305
	}
}
#else
306 307 308 309
static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
{
	return;
}
L
Linus Torvalds 已提交
310 311 312 313
#endif


/**
314 315
 * cpufreq_notify_transition - call notifier chain and adjust_jiffies
 * on frequency transition.
L
Linus Torvalds 已提交
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.
L
Linus Torvalds 已提交
320 321 322
 */
void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
{
323 324
	struct cpufreq_policy *policy;

L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
330

331
	policy = per_cpu(cpufreq_cpu_data, freqs->cpu);
L
Linus Torvalds 已提交
332
	switch (state) {
333

L
Linus Torvalds 已提交
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".
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
346 347
			}
		}
348
		srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
349
				CPUFREQ_PRECHANGE, freqs);
L
Linus Torvalds 已提交
350 351
		adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
		break;
352

L
Linus Torvalds 已提交
353 354
	case CPUFREQ_POSTCHANGE:
		adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
355 356 357
		dprintk("FREQ: %lu - CPU: %lu", (unsigned long)freqs->new,
			(unsigned long)freqs->cpu);
		trace_power_frequency(POWER_PSTATE, freqs->new, freqs->cpu);
358
		srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
359
				CPUFREQ_POSTCHANGE, freqs);
360 361
		if (likely(policy) && likely(policy->cpu == freqs->cpu))
			policy->cur = freqs->new;
L
Linus Torvalds 已提交
362 363 364 365 366 367 368 369 370 371 372
		break;
	}
}
EXPORT_SYMBOL_GPL(cpufreq_notify_transition);



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

373 374 375 376 377
static struct cpufreq_governor *__find_governor(const char *str_governor)
{
	struct cpufreq_governor *t;

	list_for_each_entry(t, &cpufreq_governor_list, governor_list)
378
		if (!strnicmp(str_governor, t->name, CPUFREQ_NAME_LEN))
379 380 381 382 383
			return t;

	return NULL;
}

L
Linus Torvalds 已提交
384 385 386
/**
 * cpufreq_parse_governor - parse a governor string
 */
D
Dave Jones 已提交
387
static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
L
Linus Torvalds 已提交
388 389
				struct cpufreq_governor **governor)
{
390 391
	int err = -EINVAL;

L
Linus Torvalds 已提交
392
	if (!cpufreq_driver)
393 394
		goto out;

L
Linus Torvalds 已提交
395 396 397
	if (cpufreq_driver->setpolicy) {
		if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
			*policy = CPUFREQ_POLICY_PERFORMANCE;
398
			err = 0;
399 400
		} else if (!strnicmp(str_governor, "powersave",
						CPUFREQ_NAME_LEN)) {
L
Linus Torvalds 已提交
401
			*policy = CPUFREQ_POLICY_POWERSAVE;
402
			err = 0;
L
Linus Torvalds 已提交
403
		}
404
	} else if (cpufreq_driver->target) {
L
Linus Torvalds 已提交
405
		struct cpufreq_governor *t;
406

407
		mutex_lock(&cpufreq_governor_mutex);
408 409 410

		t = __find_governor(str_governor);

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

			if (name) {
				int ret;

				mutex_unlock(&cpufreq_governor_mutex);
C
Chris Wright 已提交
419
				ret = request_module("%s", name);
420 421 422 423 424 425 426 427 428
				mutex_lock(&cpufreq_governor_mutex);

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

			kfree(name);
		}

429 430 431
		if (t != NULL) {
			*governor = t;
			err = 0;
L
Linus Torvalds 已提交
432
		}
433

434
		mutex_unlock(&cpufreq_governor_mutex);
L
Linus Torvalds 已提交
435
	}
436
out:
437
	return err;
L
Linus Torvalds 已提交
438 439 440 441
}


/**
442 443
 * cpufreq_per_cpu_attr_read() / show_##file_name() -
 * print out cpufreq information
L
Linus Torvalds 已提交
444 445 446 447 448
 *
 * Write out information from cpufreq_driver->policy[cpu]; object must be
 * "unsigned int".
 */

449 450
#define show_one(file_name, object)			\
static ssize_t show_##file_name				\
D
Dave Jones 已提交
451
(struct cpufreq_policy *policy, char *buf)		\
452
{							\
453
	return sprintf(buf, "%u\n", policy->object);	\
L
Linus Torvalds 已提交
454 455 456 457
}

show_one(cpuinfo_min_freq, cpuinfo.min_freq);
show_one(cpuinfo_max_freq, cpuinfo.max_freq);
458
show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
L
Linus Torvalds 已提交
459 460 461 462
show_one(scaling_min_freq, min);
show_one(scaling_max_freq, max);
show_one(scaling_cur_freq, cur);

463 464
static int __cpufreq_set_policy(struct cpufreq_policy *data,
				struct cpufreq_policy *policy);
465

L
Linus Torvalds 已提交
466 467 468 469 470
/**
 * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
 */
#define store_one(file_name, object)			\
static ssize_t store_##file_name					\
D
Dave Jones 已提交
471
(struct cpufreq_policy *policy, const char *buf, size_t count)		\
L
Linus Torvalds 已提交
472 473 474 475 476 477 478 479
{									\
	unsigned int ret = -EINVAL;					\
	struct cpufreq_policy new_policy;				\
									\
	ret = cpufreq_get_policy(&new_policy, policy->cpu);		\
	if (ret)							\
		return -EINVAL;						\
									\
480
	ret = sscanf(buf, "%u", &new_policy.object);			\
L
Linus Torvalds 已提交
481 482 483
	if (ret != 1)							\
		return -EINVAL;						\
									\
484 485
	ret = __cpufreq_set_policy(policy, &new_policy);		\
	policy->user_policy.object = policy->object;			\
L
Linus Torvalds 已提交
486 487 488 489
									\
	return ret ? ret : count;					\
}

490 491
store_one(scaling_min_freq, min);
store_one(scaling_max_freq, max);
L
Linus Torvalds 已提交
492 493 494 495

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


/**
 * store_scaling_governor - store policy for the specified CPU
 */
D
Dave Jones 已提交
525 526
static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
					const char *buf, size_t count)
L
Linus Torvalds 已提交
527 528 529 530 531 532 533 534 535
{
	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;

536
	ret = sscanf(buf, "%15s", str_governor);
L
Linus Torvalds 已提交
537 538 539
	if (ret != 1)
		return -EINVAL;

540 541
	if (cpufreq_parse_governor(str_governor, &new_policy.policy,
						&new_policy.governor))
L
Linus Torvalds 已提交
542 543
		return -EINVAL;

544 545 546 547 548 549 550
	/* 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;

551 552 553 554
	if (ret)
		return ret;
	else
		return count;
L
Linus Torvalds 已提交
555 556 557 558 559
}

/**
 * show_scaling_driver - show the cpufreq driver currently loaded
 */
D
Dave Jones 已提交
560
static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
L
Linus Torvalds 已提交
561 562 563 564 565 566 567
{
	return scnprintf(buf, CPUFREQ_NAME_LEN, "%s\n", cpufreq_driver->name);
}

/**
 * show_scaling_available_governors - show the available CPUfreq governors
 */
D
Dave Jones 已提交
568 569
static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
						char *buf)
L
Linus Torvalds 已提交
570 571 572 573 574 575 576 577 578 579
{
	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) {
580 581
		if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
		    - (CPUFREQ_NAME_LEN + 2)))
L
Linus Torvalds 已提交
582 583 584
			goto out;
		i += scnprintf(&buf[i], CPUFREQ_NAME_LEN, "%s ", t->name);
	}
585
out:
L
Linus Torvalds 已提交
586 587 588
	i += sprintf(&buf[i], "\n");
	return i;
}
589

590
static ssize_t show_cpus(const struct cpumask *mask, char *buf)
L
Linus Torvalds 已提交
591 592 593 594
{
	ssize_t i = 0;
	unsigned int cpu;

595
	for_each_cpu(cpu, mask) {
L
Linus Torvalds 已提交
596 597 598 599
		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))
600
			break;
L
Linus Torvalds 已提交
601 602 603 604 605
	}
	i += sprintf(&buf[i], "\n");
	return i;
}

606 607 608 609 610 611
/**
 * 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)
{
612
	if (cpumask_empty(policy->related_cpus))
613 614 615 616 617 618 619 620 621 622 623 624
		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);
}

625
static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
D
Dave Jones 已提交
626
					const char *buf, size_t count)
627 628 629 630
{
	unsigned int freq = 0;
	unsigned int ret;

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

	return policy->governor->show_setspeed(policy, buf);
}
L
Linus Torvalds 已提交
650

651 652 653 654 655 656 657 658 659 660 661 662 663 664 665
/**
 * show_scaling_driver - show the current cpufreq HW/BIOS limitation
 */
static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
{
	unsigned int limit;
	int ret;
	if (cpufreq_driver->bios_limit) {
		ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
		if (!ret)
			return sprintf(buf, "%u\n", limit);
	}
	return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
}

666 667 668 669 670 671 672 673 674 675 676 677 678 679
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);
L
Linus Torvalds 已提交
680

D
Dave Jones 已提交
681
static struct attribute *default_attrs[] = {
L
Linus Torvalds 已提交
682 683
	&cpuinfo_min_freq.attr,
	&cpuinfo_max_freq.attr,
684
	&cpuinfo_transition_latency.attr,
L
Linus Torvalds 已提交
685 686 687
	&scaling_min_freq.attr,
	&scaling_max_freq.attr,
	&affected_cpus.attr,
688
	&related_cpus.attr,
L
Linus Torvalds 已提交
689 690 691
	&scaling_governor.attr,
	&scaling_driver.attr,
	&scaling_available_governors.attr,
692
	&scaling_setspeed.attr,
L
Linus Torvalds 已提交
693 694 695
	NULL
};

696 697 698
struct kobject *cpufreq_global_kobject;
EXPORT_SYMBOL(cpufreq_global_kobject);

699 700
#define to_policy(k) container_of(k, struct cpufreq_policy, kobj)
#define to_attr(a) container_of(a, struct freq_attr, attr)
L
Linus Torvalds 已提交
701

702
static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
L
Linus Torvalds 已提交
703
{
D
Dave Jones 已提交
704 705
	struct cpufreq_policy *policy = to_policy(kobj);
	struct freq_attr *fattr = to_attr(attr);
706
	ssize_t ret = -EINVAL;
L
Linus Torvalds 已提交
707 708
	policy = cpufreq_cpu_get(policy->cpu);
	if (!policy)
709
		goto no_policy;
710 711

	if (lock_policy_rwsem_read(policy->cpu) < 0)
712
		goto fail;
713

714 715 716 717 718
	if (fattr->show)
		ret = fattr->show(policy, buf);
	else
		ret = -EIO;

719
	unlock_policy_rwsem_read(policy->cpu);
720
fail:
L
Linus Torvalds 已提交
721
	cpufreq_cpu_put(policy);
722
no_policy:
L
Linus Torvalds 已提交
723 724 725
	return ret;
}

D
Dave Jones 已提交
726 727
static ssize_t store(struct kobject *kobj, struct attribute *attr,
		     const char *buf, size_t count)
L
Linus Torvalds 已提交
728
{
D
Dave Jones 已提交
729 730
	struct cpufreq_policy *policy = to_policy(kobj);
	struct freq_attr *fattr = to_attr(attr);
731
	ssize_t ret = -EINVAL;
L
Linus Torvalds 已提交
732 733
	policy = cpufreq_cpu_get(policy->cpu);
	if (!policy)
734
		goto no_policy;
735 736

	if (lock_policy_rwsem_write(policy->cpu) < 0)
737
		goto fail;
738

739 740 741 742 743
	if (fattr->store)
		ret = fattr->store(policy, buf, count);
	else
		ret = -EIO;

744
	unlock_policy_rwsem_write(policy->cpu);
745
fail:
L
Linus Torvalds 已提交
746
	cpufreq_cpu_put(policy);
747
no_policy:
L
Linus Torvalds 已提交
748 749 750
	return ret;
}

D
Dave Jones 已提交
751
static void cpufreq_sysfs_release(struct kobject *kobj)
L
Linus Torvalds 已提交
752
{
D
Dave Jones 已提交
753
	struct cpufreq_policy *policy = to_policy(kobj);
L
Linus Torvalds 已提交
754 755 756 757
	dprintk("last reference is dropped\n");
	complete(&policy->kobj_unregister);
}

758
static const struct sysfs_ops sysfs_ops = {
L
Linus Torvalds 已提交
759 760 761 762 763 764 765 766 767 768
	.show	= show,
	.store	= store,
};

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

769 770 771 772 773 774
/*
 * Returns:
 *   Negative: Failure
 *   0:        Success
 *   Positive: When we have a managed CPU and the sysfs got symlinked
 */
775 776 777
static int cpufreq_add_dev_policy(unsigned int cpu,
				  struct cpufreq_policy *policy,
				  struct sys_device *sys_dev)
778 779 780 781 782 783
{
	int ret = 0;
#ifdef CONFIG_SMP
	unsigned long flags;
	unsigned int j;
#ifdef CONFIG_HOTPLUG_CPU
784 785 786 787 788
	struct cpufreq_governor *gov;

	gov = __find_governor(per_cpu(cpufreq_cpu_governor, cpu));
	if (gov) {
		policy->governor = gov;
789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809
		dprintk("Restoring governor %s for cpu %d\n",
		       policy->governor->name, cpu);
	}
#endif

	for_each_cpu(j, policy->cpus) {
		struct cpufreq_policy *managed_policy;

		if (cpu == j)
			continue;

		/* Check for existing affected CPUs.
		 * They may not be aware of it due to CPU Hotplug.
		 * cpufreq_cpu_put is called when the device is removed
		 * in __cpufreq_remove_dev()
		 */
		managed_policy = cpufreq_cpu_get(j);
		if (unlikely(managed_policy)) {

			/* Set proper policy_cpu */
			unlock_policy_rwsem_write(cpu);
810
			per_cpu(cpufreq_policy_cpu, cpu) = managed_policy->cpu;
811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837

			if (lock_policy_rwsem_write(cpu) < 0) {
				/* Should not go through policy unlock path */
				if (cpufreq_driver->exit)
					cpufreq_driver->exit(policy);
				cpufreq_cpu_put(managed_policy);
				return -EBUSY;
			}

			spin_lock_irqsave(&cpufreq_driver_lock, flags);
			cpumask_copy(managed_policy->cpus, policy->cpus);
			per_cpu(cpufreq_cpu_data, cpu) = managed_policy;
			spin_unlock_irqrestore(&cpufreq_driver_lock, flags);

			dprintk("CPU already managed, adding link\n");
			ret = sysfs_create_link(&sys_dev->kobj,
						&managed_policy->kobj,
						"cpufreq");
			if (ret)
				cpufreq_cpu_put(managed_policy);
			/*
			 * Success. We only needed to be added to the mask.
			 * Call driver->exit() because only the cpu parent of
			 * the kobj needed to call init().
			 */
			if (cpufreq_driver->exit)
				cpufreq_driver->exit(policy);
838 839 840 841 842

			if (!ret)
				return 1;
			else
				return ret;
843 844 845 846 847 848 849
		}
	}
#endif
	return ret;
}


850
/* symlink affected CPUs */
851 852
static int cpufreq_add_dev_symlink(unsigned int cpu,
				   struct cpufreq_policy *policy)
853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878
{
	unsigned int j;
	int ret = 0;

	for_each_cpu(j, policy->cpus) {
		struct cpufreq_policy *managed_policy;
		struct sys_device *cpu_sys_dev;

		if (j == cpu)
			continue;
		if (!cpu_online(j))
			continue;

		dprintk("CPU %u already managed, adding link\n", j);
		managed_policy = cpufreq_cpu_get(cpu);
		cpu_sys_dev = get_cpu_sysdev(j);
		ret = sysfs_create_link(&cpu_sys_dev->kobj, &policy->kobj,
					"cpufreq");
		if (ret) {
			cpufreq_cpu_put(managed_policy);
			return ret;
		}
	}
	return ret;
}

879 880 881
static int cpufreq_add_dev_interface(unsigned int cpu,
				     struct cpufreq_policy *policy,
				     struct sys_device *sys_dev)
882
{
883
	struct cpufreq_policy new_policy;
884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912
	struct freq_attr **drv_attr;
	unsigned long flags;
	int ret = 0;
	unsigned int j;

	/* prepare interface data */
	ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
				   &sys_dev->kobj, "cpufreq");
	if (ret)
		return ret;

	/* 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));
		if (ret)
			goto err_out_kobj_put;
		drv_attr++;
	}
	if (cpufreq_driver->get) {
		ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
		if (ret)
			goto err_out_kobj_put;
	}
	if (cpufreq_driver->target) {
		ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
		if (ret)
			goto err_out_kobj_put;
	}
913 914 915 916 917
	if (cpufreq_driver->bios_limit) {
		ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
		if (ret)
			goto err_out_kobj_put;
	}
918 919 920 921 922 923

	spin_lock_irqsave(&cpufreq_driver_lock, flags);
	for_each_cpu(j, policy->cpus) {
	if (!cpu_online(j))
		continue;
		per_cpu(cpufreq_cpu_data, j) = policy;
924
		per_cpu(cpufreq_policy_cpu, j) = policy->cpu;
925 926 927 928
	}
	spin_unlock_irqrestore(&cpufreq_driver_lock, flags);

	ret = cpufreq_add_dev_symlink(cpu, policy);
929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945
	if (ret)
		goto err_out_kobj_put;

	memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));
	/* assure that the starting sequence is run in __cpufreq_set_policy */
	policy->governor = NULL;

	/* set default policy */
	ret = __cpufreq_set_policy(policy, &new_policy);
	policy->user_policy.policy = policy->policy;
	policy->user_policy.governor = policy->governor;

	if (ret) {
		dprintk("setting policy failed\n");
		if (cpufreq_driver->exit)
			cpufreq_driver->exit(policy);
	}
946 947 948 949 950 951 952 953
	return ret;

err_out_kobj_put:
	kobject_put(&policy->kobj);
	wait_for_completion(&policy->kobj_unregister);
	return ret;
}

L
Linus Torvalds 已提交
954 955 956 957

/**
 * cpufreq_add_dev - add a CPU device
 *
958
 * Adds the cpufreq interface for a CPU device.
959 960 961 962
 *
 * The Oracle says: try running cpufreq registration/unregistration concurrently
 * with with cpu hotplugging and all hell will break loose. Tried to clean this
 * mess up, but more thorough testing is needed. - Mathieu
L
Linus Torvalds 已提交
963
 */
D
Dave Jones 已提交
964
static int cpufreq_add_dev(struct sys_device *sys_dev)
L
Linus Torvalds 已提交
965 966
{
	unsigned int cpu = sys_dev->id;
967
	int ret = 0, found = 0;
L
Linus Torvalds 已提交
968 969 970
	struct cpufreq_policy *policy;
	unsigned long flags;
	unsigned int j;
971 972 973
#ifdef CONFIG_HOTPLUG_CPU
	int sibling;
#endif
L
Linus Torvalds 已提交
974

975 976 977
	if (cpu_is_offline(cpu))
		return 0;

L
Linus Torvalds 已提交
978 979 980 981 982 983 984 985
	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)) {
986
		cpufreq_cpu_put(policy);
L
Linus Torvalds 已提交
987 988 989 990 991 992 993 994 995 996
		cpufreq_debug_enable_ratelimit();
		return 0;
	}
#endif

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

997
	ret = -ENOMEM;
998
	policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
999
	if (!policy)
L
Linus Torvalds 已提交
1000
		goto nomem_out;
1001 1002

	if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
1003
		goto err_free_policy;
1004 1005

	if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
1006
		goto err_free_cpumask;
L
Linus Torvalds 已提交
1007 1008

	policy->cpu = cpu;
1009
	cpumask_copy(policy->cpus, cpumask_of(cpu));
L
Linus Torvalds 已提交
1010

1011
	/* Initially set CPU itself as the policy_cpu */
1012
	per_cpu(cpufreq_policy_cpu, cpu) = cpu;
1013 1014
	ret = (lock_policy_rwsem_write(cpu) < 0);
	WARN_ON(ret);
1015

L
Linus Torvalds 已提交
1016
	init_completion(&policy->kobj_unregister);
1017
	INIT_WORK(&policy->update, handle_update);
L
Linus Torvalds 已提交
1018

1019
	/* Set governor before ->init, so that driver could check it */
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
#ifdef CONFIG_HOTPLUG_CPU
	for_each_online_cpu(sibling) {
		struct cpufreq_policy *cp = per_cpu(cpufreq_cpu_data, sibling);
		if (cp && cp->governor &&
		    (cpumask_test_cpu(cpu, cp->related_cpus))) {
			policy->governor = cp->governor;
			found = 1;
			break;
		}
	}
#endif
	if (!found)
		policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
L
Linus Torvalds 已提交
1033 1034 1035 1036 1037 1038
	/* 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");
1039
		goto err_unlock_policy;
L
Linus Torvalds 已提交
1040
	}
1041 1042
	policy->user_policy.min = policy->min;
	policy->user_policy.max = policy->max;
L
Linus Torvalds 已提交
1043

1044 1045 1046
	blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
				     CPUFREQ_START, policy);

1047
	ret = cpufreq_add_dev_policy(cpu, policy, sys_dev);
1048 1049 1050 1051 1052
	if (ret) {
		if (ret > 0)
			/* This is a managed cpu, symlink created,
			   exit with 0 */
			ret = 0;
1053
		goto err_unlock_policy;
1054
	}
L
Linus Torvalds 已提交
1055

1056
	ret = cpufreq_add_dev_interface(cpu, policy, sys_dev);
1057 1058
	if (ret)
		goto err_out_unregister;
1059

1060 1061
	unlock_policy_rwsem_write(cpu);

1062
	kobject_uevent(&policy->kobj, KOBJ_ADD);
L
Linus Torvalds 已提交
1063 1064 1065
	module_put(cpufreq_driver->owner);
	dprintk("initialization complete\n");
	cpufreq_debug_enable_ratelimit();
1066

L
Linus Torvalds 已提交
1067 1068 1069 1070 1071
	return 0;


err_out_unregister:
	spin_lock_irqsave(&cpufreq_driver_lock, flags);
1072
	for_each_cpu(j, policy->cpus)
1073
		per_cpu(cpufreq_cpu_data, j) = NULL;
L
Linus Torvalds 已提交
1074 1075
	spin_unlock_irqrestore(&cpufreq_driver_lock, flags);

1076
	kobject_put(&policy->kobj);
L
Linus Torvalds 已提交
1077 1078
	wait_for_completion(&policy->kobj_unregister);

1079
err_unlock_policy:
1080
	unlock_policy_rwsem_write(cpu);
1081
	free_cpumask_var(policy->related_cpus);
1082 1083 1084
err_free_cpumask:
	free_cpumask_var(policy->cpus);
err_free_policy:
L
Linus Torvalds 已提交
1085 1086 1087
	kfree(policy);
nomem_out:
	module_put(cpufreq_driver->owner);
1088
module_out:
L
Linus Torvalds 已提交
1089 1090 1091 1092 1093 1094
	cpufreq_debug_enable_ratelimit();
	return ret;
}


/**
1095
 * __cpufreq_remove_dev - remove a CPU device
L
Linus Torvalds 已提交
1096 1097
 *
 * Removes the cpufreq interface for a CPU device.
1098 1099
 * Caller should already have policy_rwsem in write mode for this CPU.
 * This routine frees the rwsem before returning.
L
Linus Torvalds 已提交
1100
 */
D
Dave Jones 已提交
1101
static int __cpufreq_remove_dev(struct sys_device *sys_dev)
L
Linus Torvalds 已提交
1102 1103 1104 1105
{
	unsigned int cpu = sys_dev->id;
	unsigned long flags;
	struct cpufreq_policy *data;
A
Amerigo Wang 已提交
1106 1107
	struct kobject *kobj;
	struct completion *cmp;
L
Linus Torvalds 已提交
1108
#ifdef CONFIG_SMP
1109
	struct sys_device *cpu_sys_dev;
L
Linus Torvalds 已提交
1110 1111 1112 1113 1114 1115 1116
	unsigned int j;
#endif

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

	spin_lock_irqsave(&cpufreq_driver_lock, flags);
1117
	data = per_cpu(cpufreq_cpu_data, cpu);
L
Linus Torvalds 已提交
1118 1119 1120 1121

	if (!data) {
		spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
		cpufreq_debug_enable_ratelimit();
1122
		unlock_policy_rwsem_write(cpu);
L
Linus Torvalds 已提交
1123 1124
		return -EINVAL;
	}
1125
	per_cpu(cpufreq_cpu_data, cpu) = NULL;
L
Linus Torvalds 已提交
1126 1127 1128 1129


#ifdef CONFIG_SMP
	/* if this isn't the CPU which is the parent of the kobj, we
1130
	 * only need to unlink, put and exit
L
Linus Torvalds 已提交
1131 1132 1133
	 */
	if (unlikely(cpu != data->cpu)) {
		dprintk("removing link\n");
1134
		cpumask_clear_cpu(cpu, data->cpus);
L
Linus Torvalds 已提交
1135
		spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
A
Amerigo Wang 已提交
1136
		kobj = &sys_dev->kobj;
L
Linus Torvalds 已提交
1137 1138
		cpufreq_cpu_put(data);
		cpufreq_debug_enable_ratelimit();
1139
		unlock_policy_rwsem_write(cpu);
A
Amerigo Wang 已提交
1140
		sysfs_remove_link(kobj, "cpufreq");
L
Linus Torvalds 已提交
1141 1142 1143 1144 1145
		return 0;
	}
#endif

#ifdef CONFIG_SMP
1146 1147

#ifdef CONFIG_HOTPLUG_CPU
1148 1149
	strncpy(per_cpu(cpufreq_cpu_governor, cpu), data->governor->name,
			CPUFREQ_NAME_LEN);
1150 1151
#endif

L
Linus Torvalds 已提交
1152 1153
	/* if we have other CPUs still registered, we need to unlink them,
	 * or else wait_for_completion below will lock up. Clean the
1154 1155
	 * per_cpu(cpufreq_cpu_data) while holding the lock, and remove
	 * the sysfs links afterwards.
L
Linus Torvalds 已提交
1156
	 */
1157 1158
	if (unlikely(cpumask_weight(data->cpus) > 1)) {
		for_each_cpu(j, data->cpus) {
L
Linus Torvalds 已提交
1159 1160
			if (j == cpu)
				continue;
1161
			per_cpu(cpufreq_cpu_data, j) = NULL;
L
Linus Torvalds 已提交
1162 1163 1164 1165 1166
		}
	}

	spin_unlock_irqrestore(&cpufreq_driver_lock, flags);

1167 1168
	if (unlikely(cpumask_weight(data->cpus) > 1)) {
		for_each_cpu(j, data->cpus) {
L
Linus Torvalds 已提交
1169 1170 1171
			if (j == cpu)
				continue;
			dprintk("removing link for cpu %u\n", j);
1172
#ifdef CONFIG_HOTPLUG_CPU
1173 1174
			strncpy(per_cpu(cpufreq_cpu_governor, j),
				data->governor->name, CPUFREQ_NAME_LEN);
1175
#endif
1176
			cpu_sys_dev = get_cpu_sysdev(j);
A
Amerigo Wang 已提交
1177 1178 1179 1180
			kobj = &cpu_sys_dev->kobj;
			unlock_policy_rwsem_write(cpu);
			sysfs_remove_link(kobj, "cpufreq");
			lock_policy_rwsem_write(cpu);
L
Linus Torvalds 已提交
1181 1182 1183 1184 1185 1186 1187 1188 1189
			cpufreq_cpu_put(data);
		}
	}
#else
	spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
#endif

	if (cpufreq_driver->target)
		__cpufreq_governor(data, CPUFREQ_GOV_STOP);
1190

A
Amerigo Wang 已提交
1191 1192 1193 1194
	kobj = &data->kobj;
	cmp = &data->kobj_unregister;
	unlock_policy_rwsem_write(cpu);
	kobject_put(kobj);
L
Linus Torvalds 已提交
1195 1196

	/* we need to make sure that the underlying kobj is actually
1197
	 * not referenced anymore by anybody before we proceed with
L
Linus Torvalds 已提交
1198 1199 1200
	 * unloading.
	 */
	dprintk("waiting for dropping of refcount\n");
A
Amerigo Wang 已提交
1201
	wait_for_completion(cmp);
L
Linus Torvalds 已提交
1202 1203
	dprintk("wait complete\n");

A
Amerigo Wang 已提交
1204
	lock_policy_rwsem_write(cpu);
L
Linus Torvalds 已提交
1205 1206
	if (cpufreq_driver->exit)
		cpufreq_driver->exit(data);
1207 1208
	unlock_policy_rwsem_write(cpu);

1209 1210
	free_cpumask_var(data->related_cpus);
	free_cpumask_var(data->cpus);
L
Linus Torvalds 已提交
1211
	kfree(data);
1212
	per_cpu(cpufreq_cpu_data, cpu) = NULL;
L
Linus Torvalds 已提交
1213 1214 1215 1216 1217 1218

	cpufreq_debug_enable_ratelimit();
	return 0;
}


D
Dave Jones 已提交
1219
static int cpufreq_remove_dev(struct sys_device *sys_dev)
1220 1221 1222
{
	unsigned int cpu = sys_dev->id;
	int retval;
1223 1224 1225 1226

	if (cpu_is_offline(cpu))
		return 0;

1227 1228 1229 1230 1231 1232 1233 1234
	if (unlikely(lock_policy_rwsem_write(cpu)))
		BUG();

	retval = __cpufreq_remove_dev(sys_dev);
	return retval;
}


1235
static void handle_update(struct work_struct *work)
L
Linus Torvalds 已提交
1236
{
1237 1238 1239
	struct cpufreq_policy *policy =
		container_of(work, struct cpufreq_policy, update);
	unsigned int cpu = policy->cpu;
L
Linus Torvalds 已提交
1240 1241 1242 1243 1244 1245 1246 1247 1248 1249
	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
 *
1250 1251
 *	We adjust to current frequency first, and need to clean up later.
 *	So either call to cpufreq_update_policy() or schedule handle_update()).
L
Linus Torvalds 已提交
1252
 */
1253 1254
static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
				unsigned int new_freq)
L
Linus Torvalds 已提交
1255 1256 1257
{
	struct cpufreq_freqs freqs;

1258
	dprintk("Warning: CPU frequency out of sync: cpufreq and timing "
L
Linus Torvalds 已提交
1259 1260 1261 1262 1263 1264 1265 1266 1267 1268
	       "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);
}


1269
/**
D
Dhaval Giani 已提交
1270
 * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
1271 1272 1273 1274 1275 1276 1277 1278
 * @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);
1279
	unsigned int ret_freq = 0;
1280 1281

	if (policy) {
1282
		ret_freq = policy->cur;
1283 1284 1285
		cpufreq_cpu_put(policy);
	}

D
Dave Jones 已提交
1286
	return ret_freq;
1287 1288 1289 1290
}
EXPORT_SYMBOL(cpufreq_quick_get);


1291
static unsigned int __cpufreq_get(unsigned int cpu)
L
Linus Torvalds 已提交
1292
{
1293
	struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
1294
	unsigned int ret_freq = 0;
L
Linus Torvalds 已提交
1295 1296

	if (!cpufreq_driver->get)
D
Dave Jones 已提交
1297
		return ret_freq;
L
Linus Torvalds 已提交
1298

1299
	ret_freq = cpufreq_driver->get(cpu);
L
Linus Torvalds 已提交
1300

1301 1302 1303 1304 1305 1306
	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);
L
Linus Torvalds 已提交
1307 1308 1309 1310
			schedule_work(&policy->update);
		}
	}

D
Dave Jones 已提交
1311
	return ret_freq;
1312
}
L
Linus Torvalds 已提交
1313

1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
/**
 * 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;

	ret_freq = __cpufreq_get(cpu);

	unlock_policy_rwsem_read(cpu);
L
Linus Torvalds 已提交
1334

1335 1336 1337
out_policy:
	cpufreq_cpu_put(policy);
out:
D
Dave Jones 已提交
1338
	return ret_freq;
L
Linus Torvalds 已提交
1339 1340 1341 1342
}
EXPORT_SYMBOL(cpufreq_get);


1343 1344 1345 1346
/**
 *	cpufreq_suspend - let the low level driver prepare for suspend
 */

D
Dave Jones 已提交
1347
static int cpufreq_suspend(struct sys_device *sysdev, pm_message_t pmsg)
1348
{
1349
	int ret = 0;
1350 1351

	int cpu = sysdev->id;
1352 1353
	struct cpufreq_policy *cpu_policy;

1354
	dprintk("suspending cpu %u\n", cpu);
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368

	if (!cpu_online(cpu))
		return 0;

	/* we may be lax here as interrupts are off. Nonetheless
	 * we need to grab the correct cpu policy, as to check
	 * whether we really run on this CPU.
	 */

	cpu_policy = cpufreq_cpu_get(cpu);
	if (!cpu_policy)
		return -EINVAL;

	/* only handle each CPU group once */
1369 1370
	if (unlikely(cpu_policy->cpu != cpu))
		goto out;
1371 1372

	if (cpufreq_driver->suspend) {
1373
		ret = cpufreq_driver->suspend(cpu_policy, pmsg);
1374
		if (ret)
1375 1376 1377 1378
			printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
					"step on CPU %u\n", cpu_policy->cpu);
	}

1379
out:
1380
	cpufreq_cpu_put(cpu_policy);
1381
	return ret;
1382 1383
}

L
Linus Torvalds 已提交
1384 1385 1386 1387
/**
 *	cpufreq_resume -  restore proper CPU frequency handling after resume
 *
 *	1.) resume CPUfreq hardware support (cpufreq_driver->resume())
1388 1389 1390 1391 1392
 *	2.) schedule call cpufreq_update_policy() ASAP as interrupts are
 *	    restored. It will verify that the current freq is in sync with
 *	    what we believe it to be. This is a bit later than when it
 *	    should be, but nonethteless it's better than calling
 *	    cpufreq_driver->get() here which might re-enable interrupts...
L
Linus Torvalds 已提交
1393
 */
D
Dave Jones 已提交
1394
static int cpufreq_resume(struct sys_device *sysdev)
L
Linus Torvalds 已提交
1395
{
1396
	int ret = 0;
1397 1398

	int cpu = sysdev->id;
L
Linus Torvalds 已提交
1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
	struct cpufreq_policy *cpu_policy;

	dprintk("resuming cpu %u\n", cpu);

	if (!cpu_online(cpu))
		return 0;

	/* we may be lax here as interrupts are off. Nonetheless
	 * we need to grab the correct cpu policy, as to check
	 * whether we really run on this CPU.
	 */

	cpu_policy = cpufreq_cpu_get(cpu);
	if (!cpu_policy)
		return -EINVAL;

	/* only handle each CPU group once */
1416 1417
	if (unlikely(cpu_policy->cpu != cpu))
		goto fail;
L
Linus Torvalds 已提交
1418 1419 1420 1421 1422 1423

	if (cpufreq_driver->resume) {
		ret = cpufreq_driver->resume(cpu_policy);
		if (ret) {
			printk(KERN_ERR "cpufreq: resume failed in ->resume "
					"step on CPU %u\n", cpu_policy->cpu);
1424
			goto fail;
L
Linus Torvalds 已提交
1425 1426 1427 1428
		}
	}

	schedule_work(&cpu_policy->update);
1429

1430
fail:
L
Linus Torvalds 已提交
1431 1432 1433 1434 1435 1436 1437
	cpufreq_cpu_put(cpu_policy);
	return ret;
}

static struct sysdev_driver cpufreq_sysdev_driver = {
	.add		= cpufreq_add_dev,
	.remove		= cpufreq_remove_dev,
1438
	.suspend	= cpufreq_suspend,
L
Linus Torvalds 已提交
1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451
	.resume		= cpufreq_resume,
};


/*********************************************************************
 *                     NOTIFIER LISTS INTERFACE                      *
 *********************************************************************/

/**
 *	cpufreq_register_notifier - register a driver with cpufreq
 *	@nb: notifier function to register
 *      @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
 *
1452
 *	Add a driver to one of two lists: either a list of drivers that
L
Linus Torvalds 已提交
1453 1454 1455 1456 1457
 *      are notified about clock rate changes (once before and once after
 *      the transition), or a list of drivers that are notified about
 *      changes in cpufreq policy.
 *
 *	This function may sleep, and has the same return conditions as
1458
 *	blocking_notifier_chain_register.
L
Linus Torvalds 已提交
1459 1460 1461 1462 1463
 */
int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
{
	int ret;

1464 1465
	WARN_ON(!init_cpufreq_transition_notifier_list_called);

L
Linus Torvalds 已提交
1466 1467
	switch (list) {
	case CPUFREQ_TRANSITION_NOTIFIER:
1468
		ret = srcu_notifier_chain_register(
1469
				&cpufreq_transition_notifier_list, nb);
L
Linus Torvalds 已提交
1470 1471
		break;
	case CPUFREQ_POLICY_NOTIFIER:
1472 1473
		ret = blocking_notifier_chain_register(
				&cpufreq_policy_notifier_list, nb);
L
Linus Torvalds 已提交
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491
		break;
	default:
		ret = -EINVAL;
	}

	return ret;
}
EXPORT_SYMBOL(cpufreq_register_notifier);


/**
 *	cpufreq_unregister_notifier - unregister a driver with cpufreq
 *	@nb: notifier block to be unregistered
 *      @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
 *
 *	Remove a driver from the CPU frequency notifier list.
 *
 *	This function may sleep, and has the same return conditions as
1492
 *	blocking_notifier_chain_unregister.
L
Linus Torvalds 已提交
1493 1494 1495 1496 1497 1498 1499
 */
int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
{
	int ret;

	switch (list) {
	case CPUFREQ_TRANSITION_NOTIFIER:
1500
		ret = srcu_notifier_chain_unregister(
1501
				&cpufreq_transition_notifier_list, nb);
L
Linus Torvalds 已提交
1502 1503
		break;
	case CPUFREQ_POLICY_NOTIFIER:
1504 1505
		ret = blocking_notifier_chain_unregister(
				&cpufreq_policy_notifier_list, nb);
L
Linus Torvalds 已提交
1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
		break;
	default:
		ret = -EINVAL;
	}

	return ret;
}
EXPORT_SYMBOL(cpufreq_unregister_notifier);


/*********************************************************************
 *                              GOVERNORS                            *
 *********************************************************************/


int __cpufreq_driver_target(struct cpufreq_policy *policy,
			    unsigned int target_freq,
			    unsigned int relation)
{
	int retval = -EINVAL;
1526

L
Linus Torvalds 已提交
1527 1528 1529 1530
	dprintk("target for CPU %u: %u kHz, relation %u\n", policy->cpu,
		target_freq, relation);
	if (cpu_online(policy->cpu) && cpufreq_driver->target)
		retval = cpufreq_driver->target(policy, target_freq, relation);
1531

L
Linus Torvalds 已提交
1532 1533 1534 1535 1536 1537 1538 1539
	return retval;
}
EXPORT_SYMBOL_GPL(__cpufreq_driver_target);

int cpufreq_driver_target(struct cpufreq_policy *policy,
			  unsigned int target_freq,
			  unsigned int relation)
{
1540
	int ret = -EINVAL;
L
Linus Torvalds 已提交
1541 1542 1543

	policy = cpufreq_cpu_get(policy->cpu);
	if (!policy)
1544
		goto no_policy;
L
Linus Torvalds 已提交
1545

1546
	if (unlikely(lock_policy_rwsem_write(policy->cpu)))
1547
		goto fail;
L
Linus Torvalds 已提交
1548 1549 1550

	ret = __cpufreq_driver_target(policy, target_freq, relation);

1551
	unlock_policy_rwsem_write(policy->cpu);
L
Linus Torvalds 已提交
1552

1553
fail:
L
Linus Torvalds 已提交
1554
	cpufreq_cpu_put(policy);
1555
no_policy:
L
Linus Torvalds 已提交
1556 1557 1558 1559
	return ret;
}
EXPORT_SYMBOL_GPL(cpufreq_driver_target);

1560
int __cpufreq_driver_getavg(struct cpufreq_policy *policy, unsigned int cpu)
1561 1562 1563 1564 1565 1566 1567
{
	int ret = 0;

	policy = cpufreq_cpu_get(policy->cpu);
	if (!policy)
		return -EINVAL;

1568 1569
	if (cpu_online(cpu) && cpufreq_driver->getavg)
		ret = cpufreq_driver->getavg(policy, cpu);
1570 1571 1572 1573

	cpufreq_cpu_put(policy);
	return ret;
}
1574
EXPORT_SYMBOL_GPL(__cpufreq_driver_getavg);
1575

1576 1577 1578
/*
 * when "event" is CPUFREQ_GOV_LIMITS
 */
L
Linus Torvalds 已提交
1579

1580 1581
static int __cpufreq_governor(struct cpufreq_policy *policy,
					unsigned int event)
L
Linus Torvalds 已提交
1582
{
1583
	int ret;
1584 1585 1586 1587 1588 1589 1590 1591 1592 1593

	/* Only must be defined when default governor is known to have latency
	   restrictions, like e.g. conservative or ondemand.
	   That this is the case is already ensured in Kconfig
	*/
#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
	struct cpufreq_governor *gov = &cpufreq_gov_performance;
#else
	struct cpufreq_governor *gov = NULL;
#endif
1594 1595 1596 1597

	if (policy->governor->max_transition_latency &&
	    policy->cpuinfo.transition_latency >
	    policy->governor->max_transition_latency) {
1598 1599 1600 1601 1602 1603 1604 1605 1606 1607
		if (!gov)
			return -EINVAL;
		else {
			printk(KERN_WARNING "%s governor failed, too long"
			       " transition latency of HW, fallback"
			       " to %s governor\n",
			       policy->governor->name,
			       gov->name);
			policy->governor = gov;
		}
1608
	}
L
Linus Torvalds 已提交
1609 1610 1611 1612

	if (!try_module_get(policy->governor->owner))
		return -EINVAL;

1613 1614
	dprintk("__cpufreq_governor for CPU %u, event %u\n",
						policy->cpu, event);
L
Linus Torvalds 已提交
1615 1616
	ret = policy->governor->governor(policy, event);

1617 1618
	/* we keep one module reference alive for
			each CPU governed by this CPU */
L
Linus Torvalds 已提交
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629
	if ((event != CPUFREQ_GOV_START) || ret)
		module_put(policy->governor->owner);
	if ((event == CPUFREQ_GOV_STOP) && !ret)
		module_put(policy->governor->owner);

	return ret;
}


int cpufreq_register_governor(struct cpufreq_governor *governor)
{
1630
	int err;
L
Linus Torvalds 已提交
1631 1632 1633 1634

	if (!governor)
		return -EINVAL;

1635
	mutex_lock(&cpufreq_governor_mutex);
1636

1637 1638 1639 1640
	err = -EBUSY;
	if (__find_governor(governor->name) == NULL) {
		err = 0;
		list_add(&governor->governor_list, &cpufreq_governor_list);
L
Linus Torvalds 已提交
1641 1642
	}

1643
	mutex_unlock(&cpufreq_governor_mutex);
1644
	return err;
L
Linus Torvalds 已提交
1645 1646 1647 1648 1649 1650
}
EXPORT_SYMBOL_GPL(cpufreq_register_governor);


void cpufreq_unregister_governor(struct cpufreq_governor *governor)
{
1651 1652 1653 1654
#ifdef CONFIG_HOTPLUG_CPU
	int cpu;
#endif

L
Linus Torvalds 已提交
1655 1656 1657
	if (!governor)
		return;

1658 1659 1660 1661 1662 1663 1664 1665 1666
#ifdef CONFIG_HOTPLUG_CPU
	for_each_present_cpu(cpu) {
		if (cpu_online(cpu))
			continue;
		if (!strcmp(per_cpu(cpufreq_cpu_governor, cpu), governor->name))
			strcpy(per_cpu(cpufreq_cpu_governor, cpu), "\0");
	}
#endif

1667
	mutex_lock(&cpufreq_governor_mutex);
L
Linus Torvalds 已提交
1668
	list_del(&governor->governor_list);
1669
	mutex_unlock(&cpufreq_governor_mutex);
L
Linus Torvalds 已提交
1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681
	return;
}
EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);



/*********************************************************************
 *                          POLICY INTERFACE                         *
 *********************************************************************/

/**
 * cpufreq_get_policy - get the current cpufreq_policy
1682 1683
 * @policy: struct cpufreq_policy into which the current cpufreq_policy
 *	is written
L
Linus Torvalds 已提交
1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
 *
 * Reads the current cpufreq policy.
 */
int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
{
	struct cpufreq_policy *cpu_policy;
	if (!policy)
		return -EINVAL;

	cpu_policy = cpufreq_cpu_get(cpu);
	if (!cpu_policy)
		return -EINVAL;

	memcpy(policy, cpu_policy, sizeof(struct cpufreq_policy));

	cpufreq_cpu_put(cpu_policy);
	return 0;
}
EXPORT_SYMBOL(cpufreq_get_policy);


1705
/*
1706 1707
 * data   : current policy.
 * policy : policy to be set.
1708
 */
1709 1710
static int __cpufreq_set_policy(struct cpufreq_policy *data,
				struct cpufreq_policy *policy)
L
Linus Torvalds 已提交
1711 1712 1713 1714 1715 1716 1717
{
	int ret = 0;

	cpufreq_debug_disable_ratelimit();
	dprintk("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
		policy->min, policy->max);

1718 1719
	memcpy(&policy->cpuinfo, &data->cpuinfo,
				sizeof(struct cpufreq_cpuinfo));
L
Linus Torvalds 已提交
1720

1721
	if (policy->min > data->max || policy->max < data->min) {
1722 1723 1724 1725
		ret = -EINVAL;
		goto error_out;
	}

L
Linus Torvalds 已提交
1726 1727 1728 1729 1730 1731
	/* verify the cpu speed can be set within this limit */
	ret = cpufreq_driver->verify(policy);
	if (ret)
		goto error_out;

	/* adjust if necessary - all reasons */
1732 1733
	blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
			CPUFREQ_ADJUST, policy);
L
Linus Torvalds 已提交
1734 1735

	/* adjust if necessary - hardware incompatibility*/
1736 1737
	blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
			CPUFREQ_INCOMPATIBLE, policy);
L
Linus Torvalds 已提交
1738 1739 1740 1741

	/* verify the cpu speed can be set within this limit,
	   which might be different to the first one */
	ret = cpufreq_driver->verify(policy);
1742
	if (ret)
L
Linus Torvalds 已提交
1743 1744 1745
		goto error_out;

	/* notification of the new policy */
1746 1747
	blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
			CPUFREQ_NOTIFY, policy);
L
Linus Torvalds 已提交
1748

1749 1750
	data->min = policy->min;
	data->max = policy->max;
L
Linus Torvalds 已提交
1751

1752 1753
	dprintk("new min and max freqs are %u - %u kHz\n",
					data->min, data->max);
L
Linus Torvalds 已提交
1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766

	if (cpufreq_driver->setpolicy) {
		data->policy = policy->policy;
		dprintk("setting range\n");
		ret = cpufreq_driver->setpolicy(policy);
	} else {
		if (policy->governor != data->governor) {
			/* save old, working values */
			struct cpufreq_governor *old_gov = data->governor;

			dprintk("governor switch\n");

			/* end old governor */
1767
			if (data->governor)
L
Linus Torvalds 已提交
1768 1769 1770 1771 1772 1773
				__cpufreq_governor(data, CPUFREQ_GOV_STOP);

			/* start new governor */
			data->governor = policy->governor;
			if (__cpufreq_governor(data, CPUFREQ_GOV_START)) {
				/* new governor failed, so re-start old one */
1774 1775
				dprintk("starting governor %s failed\n",
							data->governor->name);
L
Linus Torvalds 已提交
1776 1777
				if (old_gov) {
					data->governor = old_gov;
1778 1779
					__cpufreq_governor(data,
							   CPUFREQ_GOV_START);
L
Linus Torvalds 已提交
1780 1781 1782 1783 1784 1785 1786 1787 1788 1789
				}
				ret = -EINVAL;
				goto error_out;
			}
			/* might be a policy change, too, so fall through */
		}
		dprintk("governor: change or update limits\n");
		__cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
	}

1790
error_out:
L
Linus Torvalds 已提交
1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805
	cpufreq_debug_enable_ratelimit();
	return ret;
}

/**
 *	cpufreq_update_policy - re-evaluate an existing cpufreq policy
 *	@cpu: CPU which shall be re-evaluated
 *
 *	Usefull for policy notifiers which have different necessities
 *	at different times.
 */
int cpufreq_update_policy(unsigned int cpu)
{
	struct cpufreq_policy *data = cpufreq_cpu_get(cpu);
	struct cpufreq_policy policy;
1806
	int ret;
L
Linus Torvalds 已提交
1807

1808 1809 1810 1811
	if (!data) {
		ret = -ENODEV;
		goto no_policy;
	}
L
Linus Torvalds 已提交
1812

1813 1814 1815 1816
	if (unlikely(lock_policy_rwsem_write(cpu))) {
		ret = -EINVAL;
		goto fail;
	}
L
Linus Torvalds 已提交
1817 1818

	dprintk("updating policy for CPU %u\n", cpu);
1819
	memcpy(&policy, data, sizeof(struct cpufreq_policy));
L
Linus Torvalds 已提交
1820 1821 1822 1823 1824
	policy.min = data->user_policy.min;
	policy.max = data->user_policy.max;
	policy.policy = data->user_policy.policy;
	policy.governor = data->user_policy.governor;

1825 1826 1827 1828
	/* BIOS might change freq behind our back
	  -> ask driver for current freq and notify governors about a change */
	if (cpufreq_driver->get) {
		policy.cur = cpufreq_driver->get(cpu);
1829 1830 1831 1832 1833
		if (!data->cur) {
			dprintk("Driver did not initialize current freq");
			data->cur = policy.cur;
		} else {
			if (data->cur != policy.cur)
1834 1835
				cpufreq_out_of_sync(cpu, data->cur,
								policy.cur);
1836
		}
1837 1838
	}

L
Linus Torvalds 已提交
1839 1840
	ret = __cpufreq_set_policy(data, &policy);

1841 1842
	unlock_policy_rwsem_write(cpu);

1843
fail:
L
Linus Torvalds 已提交
1844
	cpufreq_cpu_put(data);
1845
no_policy:
L
Linus Torvalds 已提交
1846 1847 1848 1849
	return ret;
}
EXPORT_SYMBOL(cpufreq_update_policy);

1850
static int __cpuinit cpufreq_cpu_callback(struct notifier_block *nfb,
1851 1852 1853 1854 1855 1856 1857 1858 1859
					unsigned long action, void *hcpu)
{
	unsigned int cpu = (unsigned long)hcpu;
	struct sys_device *sys_dev;

	sys_dev = get_cpu_sysdev(cpu);
	if (sys_dev) {
		switch (action) {
		case CPU_ONLINE:
1860
		case CPU_ONLINE_FROZEN:
1861 1862 1863
			cpufreq_add_dev(sys_dev);
			break;
		case CPU_DOWN_PREPARE:
1864
		case CPU_DOWN_PREPARE_FROZEN:
1865 1866 1867 1868
			if (unlikely(lock_policy_rwsem_write(cpu)))
				BUG();

			__cpufreq_remove_dev(sys_dev);
1869
			break;
1870
		case CPU_DOWN_FAILED:
1871
		case CPU_DOWN_FAILED_FROZEN:
1872
			cpufreq_add_dev(sys_dev);
1873 1874 1875 1876 1877 1878
			break;
		}
	}
	return NOTIFY_OK;
}

1879
static struct notifier_block __refdata cpufreq_cpu_notifier = {
1880 1881
    .notifier_call = cpufreq_cpu_callback,
};
L
Linus Torvalds 已提交
1882 1883 1884 1885 1886 1887 1888 1889 1890 1891

/*********************************************************************
 *               REGISTER / UNREGISTER CPUFREQ DRIVER                *
 *********************************************************************/

/**
 * cpufreq_register_driver - register a CPU Frequency driver
 * @driver_data: A struct cpufreq_driver containing the values#
 * submitted by the CPU Frequency driver.
 *
1892
 *   Registers a CPU Frequency driver to this core code. This code
L
Linus Torvalds 已提交
1893
 * returns zero on success, -EBUSY when another driver got here first
1894
 * (and isn't unregistered in the meantime).
L
Linus Torvalds 已提交
1895 1896
 *
 */
1897
int cpufreq_register_driver(struct cpufreq_driver *driver_data)
L
Linus Torvalds 已提交
1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
{
	unsigned long flags;
	int ret;

	if (!driver_data || !driver_data->verify || !driver_data->init ||
	    ((!driver_data->setpolicy) && (!driver_data->target)))
		return -EINVAL;

	dprintk("trying to register driver %s\n", driver_data->name);

	if (driver_data->setpolicy)
		driver_data->flags |= CPUFREQ_CONST_LOOPS;

	spin_lock_irqsave(&cpufreq_driver_lock, flags);
	if (cpufreq_driver) {
		spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
		return -EBUSY;
	}
	cpufreq_driver = driver_data;
	spin_unlock_irqrestore(&cpufreq_driver_lock, flags);

1919 1920
	ret = sysdev_driver_register(&cpu_sysdev_class,
					&cpufreq_sysdev_driver);
L
Linus Torvalds 已提交
1921 1922 1923 1924 1925 1926

	if ((!ret) && !(cpufreq_driver->flags & CPUFREQ_STICKY)) {
		int i;
		ret = -ENODEV;

		/* check for at least one working CPU */
1927 1928
		for (i = 0; i < nr_cpu_ids; i++)
			if (cpu_possible(i) && per_cpu(cpufreq_cpu_data, i)) {
L
Linus Torvalds 已提交
1929
				ret = 0;
1930 1931
				break;
			}
L
Linus Torvalds 已提交
1932 1933 1934

		/* if all ->init() calls failed, unregister */
		if (ret) {
1935 1936 1937 1938
			dprintk("no CPU initialized for driver %s\n",
							driver_data->name);
			sysdev_driver_unregister(&cpu_sysdev_class,
						&cpufreq_sysdev_driver);
L
Linus Torvalds 已提交
1939 1940 1941 1942 1943 1944 1945 1946

			spin_lock_irqsave(&cpufreq_driver_lock, flags);
			cpufreq_driver = NULL;
			spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
		}
	}

	if (!ret) {
1947
		register_hotcpu_notifier(&cpufreq_cpu_notifier);
L
Linus Torvalds 已提交
1948 1949 1950 1951
		dprintk("driver %s up and running\n", driver_data->name);
		cpufreq_debug_enable_ratelimit();
	}

D
Dave Jones 已提交
1952
	return ret;
L
Linus Torvalds 已提交
1953 1954 1955 1956 1957 1958 1959
}
EXPORT_SYMBOL_GPL(cpufreq_register_driver);


/**
 * cpufreq_unregister_driver - unregister the current CPUFreq driver
 *
1960
 *    Unregister the current CPUFreq driver. Only call this if you have
L
Linus Torvalds 已提交
1961 1962 1963 1964
 * the right to do so, i.e. if you have succeeded in initialising before!
 * Returns zero if successful, and -EINVAL if the cpufreq_driver is
 * currently not initialised.
 */
1965
int cpufreq_unregister_driver(struct cpufreq_driver *driver)
L
Linus Torvalds 已提交
1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978
{
	unsigned long flags;

	cpufreq_debug_disable_ratelimit();

	if (!cpufreq_driver || (driver != cpufreq_driver)) {
		cpufreq_debug_enable_ratelimit();
		return -EINVAL;
	}

	dprintk("unregistering driver %s\n", driver->name);

	sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver);
1979
	unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
L
Linus Torvalds 已提交
1980 1981 1982 1983 1984 1985 1986 1987

	spin_lock_irqsave(&cpufreq_driver_lock, flags);
	cpufreq_driver = NULL;
	spin_unlock_irqrestore(&cpufreq_driver_lock, flags);

	return 0;
}
EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
1988 1989 1990 1991 1992 1993

static int __init cpufreq_core_init(void)
{
	int cpu;

	for_each_possible_cpu(cpu) {
1994
		per_cpu(cpufreq_policy_cpu, cpu) = -1;
1995 1996
		init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
	}
1997 1998 1999 2000 2001

	cpufreq_global_kobject = kobject_create_and_add("cpufreq",
						&cpu_sysdev_class.kset.kobj);
	BUG_ON(!cpufreq_global_kobject);

2002 2003 2004
	return 0;
}
core_initcall(cpufreq_core_init);