processor_idle.c 30.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8
/*
 * processor_idle - idle state submodule to the ACPI processor driver
 *
 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 *  Copyright (C) 2004       Dominik Brodowski <linux@brodo.de>
 *  Copyright (C) 2004  Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
 *  			- Added processor hotplug support
9 10
 *  Copyright (C) 2005  Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
 *  			- Added support for C3 on SMP
L
Linus Torvalds 已提交
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or (at
 *  your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/cpufreq.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/acpi.h>
#include <linux/dmi.h>
#include <linux/moduleparam.h>
T
Tim Schmielau 已提交
40
#include <linux/sched.h>	/* need_resched() */
L
Linus Torvalds 已提交
41 42 43 44 45 46 47 48 49 50 51

#include <asm/io.h>
#include <asm/uaccess.h>

#include <acpi/acpi_bus.h>
#include <acpi/processor.h>

#define ACPI_PROCESSOR_COMPONENT        0x01000000
#define ACPI_PROCESSOR_CLASS            "processor"
#define ACPI_PROCESSOR_DRIVER_NAME      "ACPI Processor Driver"
#define _COMPONENT              ACPI_PROCESSOR_COMPONENT
L
Len Brown 已提交
52
ACPI_MODULE_NAME("acpi_processor")
L
Linus Torvalds 已提交
53 54 55 56
#define ACPI_PROCESSOR_FILE_POWER	"power"
#define US_TO_PM_TIMER_TICKS(t)		((t * (PM_TIMER_FREQUENCY/1000)) / 1000)
#define C2_OVERHEAD			4	/* 1us (3.579 ticks per us) */
#define C3_OVERHEAD			4	/* 1us (3.579 ticks per us) */
57
static void (*pm_idle_save) (void) __read_mostly;
L
Linus Torvalds 已提交
58 59
module_param(max_cstate, uint, 0644);

60
static unsigned int nocst __read_mostly;
L
Linus Torvalds 已提交
61 62 63 64 65 66 67 68 69
module_param(nocst, uint, 0000);

/*
 * bm_history -- bit-mask with a bit per jiffy of bus-master activity
 * 1000 HZ: 0xFFFFFFFF: 32 jiffies = 32ms
 * 800 HZ: 0xFFFFFFFF: 32 jiffies = 40ms
 * 100 HZ: 0x0000000F: 4 jiffies = 40ms
 * reduce history for more aggressive entry into C3
 */
70
static unsigned int bm_history __read_mostly =
L
Len Brown 已提交
71
    (HZ >= 800 ? 0xFFFFFFFF : ((1U << (HZ / 25)) - 1));
L
Linus Torvalds 已提交
72 73 74 75 76 77 78 79 80 81 82
module_param(bm_history, uint, 0644);
/* --------------------------------------------------------------------------
                                Power Management
   -------------------------------------------------------------------------- */

/*
 * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3.
 * For now disable this. Probably a bug somewhere else.
 *
 * To skip this limit, boot/load with a large max_cstate limit.
 */
83
static int set_max_cstate(struct dmi_system_id *id)
L
Linus Torvalds 已提交
84 85 86 87
{
	if (max_cstate > ACPI_PROCESSOR_MAX_POWER)
		return 0;

88
	printk(KERN_NOTICE PREFIX "%s detected - limiting to C%ld max_cstate."
L
Len Brown 已提交
89 90
	       " Override with \"processor.max_cstate=%d\"\n", id->ident,
	       (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1);
L
Linus Torvalds 已提交
91

92
	max_cstate = (long)id->driver_data;
L
Linus Torvalds 已提交
93 94 95 96

	return 0;
}

97 98 99
/* Actually this shouldn't be __cpuinitdata, would be better to fix the
   callers to only run once -AK */
static struct dmi_system_id __cpuinitdata processor_power_dmi_table[] = {
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
	{ set_max_cstate, "IBM ThinkPad R40e", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
	  DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW")}, (void *)1},
	{ set_max_cstate, "IBM ThinkPad R40e", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
	  DMI_MATCH(DMI_BIOS_VERSION,"1SET43WW") }, (void*)1},
	{ set_max_cstate, "IBM ThinkPad R40e", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
	  DMI_MATCH(DMI_BIOS_VERSION,"1SET45WW") }, (void*)1},
	{ set_max_cstate, "IBM ThinkPad R40e", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
	  DMI_MATCH(DMI_BIOS_VERSION,"1SET47WW") }, (void*)1},
	{ set_max_cstate, "IBM ThinkPad R40e", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
	  DMI_MATCH(DMI_BIOS_VERSION,"1SET50WW") }, (void*)1},
	{ set_max_cstate, "IBM ThinkPad R40e", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
	  DMI_MATCH(DMI_BIOS_VERSION,"1SET52WW") }, (void*)1},
	{ set_max_cstate, "IBM ThinkPad R40e", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
	  DMI_MATCH(DMI_BIOS_VERSION,"1SET55WW") }, (void*)1},
	{ set_max_cstate, "IBM ThinkPad R40e", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
	  DMI_MATCH(DMI_BIOS_VERSION,"1SET56WW") }, (void*)1},
	{ set_max_cstate, "IBM ThinkPad R40e", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
	  DMI_MATCH(DMI_BIOS_VERSION,"1SET59WW") }, (void*)1},
	{ set_max_cstate, "IBM ThinkPad R40e", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
	  DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW") }, (void*)1},
	{ set_max_cstate, "IBM ThinkPad R40e", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
	  DMI_MATCH(DMI_BIOS_VERSION,"1SET61WW") }, (void*)1},
	{ set_max_cstate, "IBM ThinkPad R40e", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
	  DMI_MATCH(DMI_BIOS_VERSION,"1SET62WW") }, (void*)1},
	{ set_max_cstate, "IBM ThinkPad R40e", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
	  DMI_MATCH(DMI_BIOS_VERSION,"1SET64WW") }, (void*)1},
	{ set_max_cstate, "IBM ThinkPad R40e", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
	  DMI_MATCH(DMI_BIOS_VERSION,"1SET65WW") }, (void*)1},
	{ set_max_cstate, "IBM ThinkPad R40e", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
	  DMI_MATCH(DMI_BIOS_VERSION,"1SET68WW") }, (void*)1},
	{ set_max_cstate, "Medion 41700", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
	  DMI_MATCH(DMI_BIOS_VERSION,"R01-A1J")}, (void *)1},
	{ set_max_cstate, "Clevo 5600D", {
	  DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
	  DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")},
L
Len Brown 已提交
151
	 (void *)2},
L
Linus Torvalds 已提交
152 153 154
	{},
};

L
Len Brown 已提交
155
static inline u32 ticks_elapsed(u32 t1, u32 t2)
L
Linus Torvalds 已提交
156 157 158 159 160 161 162 163 164 165
{
	if (t2 >= t1)
		return (t2 - t1);
	else if (!acpi_fadt.tmr_val_ext)
		return (((0x00FFFFFF - t1) + t2) & 0x00FFFFFF);
	else
		return ((0xFFFFFFFF - t1) + t2);
}

static void
L
Len Brown 已提交
166 167
acpi_processor_power_activate(struct acpi_processor *pr,
			      struct acpi_processor_cx *new)
L
Linus Torvalds 已提交
168
{
L
Len Brown 已提交
169
	struct acpi_processor_cx *old;
L
Linus Torvalds 已提交
170 171 172 173 174 175 176 177

	if (!pr || !new)
		return;

	old = pr->power.state;

	if (old)
		old->promotion.count = 0;
L
Len Brown 已提交
178
	new->demotion.count = 0;
L
Linus Torvalds 已提交
179 180 181 182 183 184

	/* Cleanup from old state. */
	if (old) {
		switch (old->type) {
		case ACPI_STATE_C3:
			/* Disable bus master reload */
185
			if (new->type != ACPI_STATE_C3 && pr->flags.bm_check)
L
Len Brown 已提交
186 187
				acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 0,
						  ACPI_MTX_DO_NOT_LOCK);
L
Linus Torvalds 已提交
188 189 190 191 192 193 194 195
			break;
		}
	}

	/* Prepare to use new state. */
	switch (new->type) {
	case ACPI_STATE_C3:
		/* Enable bus master reload */
196
		if (old->type != ACPI_STATE_C3 && pr->flags.bm_check)
L
Len Brown 已提交
197 198
			acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 1,
					  ACPI_MTX_DO_NOT_LOCK);
L
Linus Torvalds 已提交
199 200 201 202 203 204 205 206
		break;
	}

	pr->power.state = new;

	return;
}

207 208
static void acpi_safe_halt(void)
{
209 210
	clear_thread_flag(TIF_POLLING_NRFLAG);
	smp_mb__after_clear_bit();
211 212
	if (!need_resched())
		safe_halt();
213
	set_thread_flag(TIF_POLLING_NRFLAG);
214 215
}

L
Len Brown 已提交
216
static atomic_t c3_cpu_count;
L
Linus Torvalds 已提交
217

L
Len Brown 已提交
218
static void acpi_processor_idle(void)
L
Linus Torvalds 已提交
219
{
L
Len Brown 已提交
220
	struct acpi_processor *pr = NULL;
L
Linus Torvalds 已提交
221 222
	struct acpi_processor_cx *cx = NULL;
	struct acpi_processor_cx *next_state = NULL;
L
Len Brown 已提交
223 224
	int sleep_ticks = 0;
	u32 t1, t2 = 0;
L
Linus Torvalds 已提交
225

226
	pr = processors[smp_processor_id()];
L
Linus Torvalds 已提交
227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
	if (!pr)
		return;

	/*
	 * Interrupts must be disabled during bus mastering calculations and
	 * for C2/C3 transitions.
	 */
	local_irq_disable();

	/*
	 * Check whether we truly need to go idle, or should
	 * reschedule:
	 */
	if (unlikely(need_resched())) {
		local_irq_enable();
		return;
	}

	cx = pr->power.state;
246 247 248 249 250 251 252
	if (!cx) {
		if (pm_idle_save)
			pm_idle_save();
		else
			acpi_safe_halt();
		return;
	}
L
Linus Torvalds 已提交
253 254 255 256 257 258 259 260

	/*
	 * Check BM Activity
	 * -----------------
	 * Check for bus mastering activity (if required), record, and check
	 * for demotion.
	 */
	if (pr->flags.bm_check) {
L
Len Brown 已提交
261 262
		u32 bm_status = 0;
		unsigned long diff = jiffies - pr->power.bm_check_timestamp;
L
Linus Torvalds 已提交
263 264 265 266 267 268 269 270 271 272 273 274 275

		if (diff > 32)
			diff = 32;

		while (diff) {
			/* if we didn't get called, assume there was busmaster activity */
			diff--;
			if (diff)
				pr->power.bm_activity |= 0x1;
			pr->power.bm_activity <<= 1;
		}

		acpi_get_register(ACPI_BITREG_BUS_MASTER_STATUS,
L
Len Brown 已提交
276
				  &bm_status, ACPI_MTX_DO_NOT_LOCK);
L
Linus Torvalds 已提交
277 278 279
		if (bm_status) {
			pr->power.bm_activity++;
			acpi_set_register(ACPI_BITREG_BUS_MASTER_STATUS,
L
Len Brown 已提交
280
					  1, ACPI_MTX_DO_NOT_LOCK);
L
Linus Torvalds 已提交
281 282 283 284 285 286 287 288
		}
		/*
		 * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect
		 * the true state of bus mastering activity; forcing us to
		 * manually check the BMIDEA bit of each IDE channel.
		 */
		else if (errata.piix4.bmisx) {
			if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01)
L
Len Brown 已提交
289
			    || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01))
L
Linus Torvalds 已提交
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
				pr->power.bm_activity++;
		}

		pr->power.bm_check_timestamp = jiffies;

		/*
		 * Apply bus mastering demotion policy.  Automatically demote
		 * to avoid a faulty transition.  Note that the processor
		 * won't enter a low-power state during this call (to this
		 * funciton) but should upon the next.
		 *
		 * TBD: A better policy might be to fallback to the demotion
		 *      state (use it for this quantum only) istead of
		 *      demoting -- and rely on duration as our sole demotion
		 *      qualification.  This may, however, introduce DMA
		 *      issues (e.g. floppy DMA transfer overrun/underrun).
		 */
		if (pr->power.bm_activity & cx->demotion.threshold.bm) {
			local_irq_enable();
			next_state = cx->demotion.state;
			goto end;
		}
	}

314 315 316 317 318 319 320
#ifdef CONFIG_HOTPLUG_CPU
	/*
	 * Check for P_LVL2_UP flag before entering C2 and above on
	 * an SMP system. We do it here instead of doing it at _CST/P_LVL
	 * detection phase, to work cleanly with logical CPU hotplug.
	 */
	if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) && 
321 322
	    !pr->flags.has_cst && !acpi_fadt.plvl2_up)
		cx = &pr->power.states[ACPI_STATE_C1];
323
#endif
324 325 326

	cx->usage++;

L
Linus Torvalds 已提交
327 328 329 330 331
	/*
	 * Sleep:
	 * ------
	 * Invoke the current Cx state to put the processor to sleep.
	 */
332 333 334 335 336
	if (cx->type == ACPI_STATE_C2 || cx->type == ACPI_STATE_C3) {
		clear_thread_flag(TIF_POLLING_NRFLAG);
		smp_mb__after_clear_bit();
		if (need_resched()) {
			set_thread_flag(TIF_POLLING_NRFLAG);
337
			local_irq_enable();
338 339 340 341
			return;
		}
	}

L
Linus Torvalds 已提交
342 343 344 345 346 347 348 349 350 351 352
	switch (cx->type) {

	case ACPI_STATE_C1:
		/*
		 * Invoke C1.
		 * Use the appropriate idle routine, the one that would
		 * be used without acpi C-states.
		 */
		if (pm_idle_save)
			pm_idle_save();
		else
353 354
			acpi_safe_halt();

L
Linus Torvalds 已提交
355
		/*
L
Len Brown 已提交
356
		 * TBD: Can't get time duration while in C1, as resumes
L
Linus Torvalds 已提交
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
		 *      go to an ISR rather than here.  Need to instrument
		 *      base interrupt handler.
		 */
		sleep_ticks = 0xFFFFFFFF;
		break;

	case ACPI_STATE_C2:
		/* Get start time (ticks) */
		t1 = inl(acpi_fadt.xpm_tmr_blk.address);
		/* Invoke C2 */
		inb(cx->address);
		/* Dummy op - must do something useless after P_LVL2 read */
		t2 = inl(acpi_fadt.xpm_tmr_blk.address);
		/* Get end time (ticks) */
		t2 = inl(acpi_fadt.xpm_tmr_blk.address);
		/* Re-enable interrupts */
		local_irq_enable();
374
		set_thread_flag(TIF_POLLING_NRFLAG);
L
Linus Torvalds 已提交
375
		/* Compute time (ticks) that we were actually asleep */
L
Len Brown 已提交
376 377
		sleep_ticks =
		    ticks_elapsed(t1, t2) - cx->latency_ticks - C2_OVERHEAD;
L
Linus Torvalds 已提交
378 379 380
		break;

	case ACPI_STATE_C3:
L
Len Brown 已提交
381

382 383
		if (pr->flags.bm_check) {
			if (atomic_inc_return(&c3_cpu_count) ==
L
Len Brown 已提交
384
			    num_online_cpus()) {
385 386 387 388 389
				/*
				 * All CPUs are trying to go to C3
				 * Disable bus master arbitration
				 */
				acpi_set_register(ACPI_BITREG_ARB_DISABLE, 1,
L
Len Brown 已提交
390
						  ACPI_MTX_DO_NOT_LOCK);
391 392 393 394 395
			}
		} else {
			/* SMP with no shared cache... Invalidate cache  */
			ACPI_FLUSH_CPU_CACHE();
		}
L
Len Brown 已提交
396

L
Linus Torvalds 已提交
397 398 399 400 401 402 403 404
		/* Get start time (ticks) */
		t1 = inl(acpi_fadt.xpm_tmr_blk.address);
		/* Invoke C3 */
		inb(cx->address);
		/* Dummy op - must do something useless after P_LVL3 read */
		t2 = inl(acpi_fadt.xpm_tmr_blk.address);
		/* Get end time (ticks) */
		t2 = inl(acpi_fadt.xpm_tmr_blk.address);
405 406 407
		if (pr->flags.bm_check) {
			/* Enable bus master arbitration */
			atomic_dec(&c3_cpu_count);
L
Len Brown 已提交
408 409
			acpi_set_register(ACPI_BITREG_ARB_DISABLE, 0,
					  ACPI_MTX_DO_NOT_LOCK);
410 411
		}

L
Linus Torvalds 已提交
412 413
		/* Re-enable interrupts */
		local_irq_enable();
414
		set_thread_flag(TIF_POLLING_NRFLAG);
L
Linus Torvalds 已提交
415
		/* Compute time (ticks) that we were actually asleep */
L
Len Brown 已提交
416 417
		sleep_ticks =
		    ticks_elapsed(t1, t2) - cx->latency_ticks - C3_OVERHEAD;
L
Linus Torvalds 已提交
418 419 420 421 422 423 424 425 426
		break;

	default:
		local_irq_enable();
		return;
	}

	next_state = pr->power.state;

427 428 429 430 431 432 433 434 435
#ifdef CONFIG_HOTPLUG_CPU
	/* Don't do promotion/demotion */
	if ((cx->type == ACPI_STATE_C1) && (num_online_cpus() > 1) &&
	    !pr->flags.has_cst && !acpi_fadt.plvl2_up) {
		next_state = cx;
		goto end;
	}
#endif

L
Linus Torvalds 已提交
436 437 438 439 440 441 442 443 444 445 446 447
	/*
	 * Promotion?
	 * ----------
	 * Track the number of longs (time asleep is greater than threshold)
	 * and promote when the count threshold is reached.  Note that bus
	 * mastering activity may prevent promotions.
	 * Do not promote above max_cstate.
	 */
	if (cx->promotion.state &&
	    ((cx->promotion.state - pr->power.states) <= max_cstate)) {
		if (sleep_ticks > cx->promotion.threshold.ticks) {
			cx->promotion.count++;
L
Len Brown 已提交
448 449 450
			cx->demotion.count = 0;
			if (cx->promotion.count >=
			    cx->promotion.threshold.count) {
L
Linus Torvalds 已提交
451
				if (pr->flags.bm_check) {
L
Len Brown 已提交
452 453 454 455 456
					if (!
					    (pr->power.bm_activity & cx->
					     promotion.threshold.bm)) {
						next_state =
						    cx->promotion.state;
L
Linus Torvalds 已提交
457 458
						goto end;
					}
L
Len Brown 已提交
459
				} else {
L
Linus Torvalds 已提交
460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483
					next_state = cx->promotion.state;
					goto end;
				}
			}
		}
	}

	/*
	 * Demotion?
	 * ---------
	 * Track the number of shorts (time asleep is less than time threshold)
	 * and demote when the usage threshold is reached.
	 */
	if (cx->demotion.state) {
		if (sleep_ticks < cx->demotion.threshold.ticks) {
			cx->demotion.count++;
			cx->promotion.count = 0;
			if (cx->demotion.count >= cx->demotion.threshold.count) {
				next_state = cx->demotion.state;
				goto end;
			}
		}
	}

L
Len Brown 已提交
484
      end:
L
Linus Torvalds 已提交
485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502
	/*
	 * Demote if current state exceeds max_cstate
	 */
	if ((pr->power.state - pr->power.states) > max_cstate) {
		if (cx->demotion.state)
			next_state = cx->demotion.state;
	}

	/*
	 * New Cx State?
	 * -------------
	 * If we're going to start using a new Cx state we must clean up
	 * from the previous and prepare to use the new.
	 */
	if (next_state != pr->power.state)
		acpi_processor_power_activate(pr, next_state);
}

L
Len Brown 已提交
503
static int acpi_processor_set_power_policy(struct acpi_processor *pr)
L
Linus Torvalds 已提交
504 505 506 507 508 509 510
{
	unsigned int i;
	unsigned int state_is_set = 0;
	struct acpi_processor_cx *lower = NULL;
	struct acpi_processor_cx *higher = NULL;
	struct acpi_processor_cx *cx;

L
Len Brown 已提交
511
	ACPI_FUNCTION_TRACE("acpi_processor_set_power_policy");
L
Linus Torvalds 已提交
512 513 514 515 516 517 518 519 520 521 522 523 524 525

	if (!pr)
		return_VALUE(-EINVAL);

	/*
	 * This function sets the default Cx state policy (OS idle handler).
	 * Our scheme is to promote quickly to C2 but more conservatively
	 * to C3.  We're favoring C2  for its characteristics of low latency
	 * (quick response), good power savings, and ability to allow bus
	 * mastering activity.  Note that the Cx state policy is completely
	 * customizable and can be altered dynamically.
	 */

	/* startup state */
L
Len Brown 已提交
526
	for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
L
Linus Torvalds 已提交
527 528 529 530 531 532 533 534
		cx = &pr->power.states[i];
		if (!cx->valid)
			continue;

		if (!state_is_set)
			pr->power.state = cx;
		state_is_set++;
		break;
L
Len Brown 已提交
535
	}
L
Linus Torvalds 已提交
536 537 538 539 540

	if (!state_is_set)
		return_VALUE(-ENODEV);

	/* demotion */
L
Len Brown 已提交
541
	for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
L
Linus Torvalds 已提交
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
		cx = &pr->power.states[i];
		if (!cx->valid)
			continue;

		if (lower) {
			cx->demotion.state = lower;
			cx->demotion.threshold.ticks = cx->latency_ticks;
			cx->demotion.threshold.count = 1;
			if (cx->type == ACPI_STATE_C3)
				cx->demotion.threshold.bm = bm_history;
		}

		lower = cx;
	}

	/* promotion */
	for (i = (ACPI_PROCESSOR_MAX_POWER - 1); i > 0; i--) {
		cx = &pr->power.states[i];
		if (!cx->valid)
			continue;

		if (higher) {
L
Len Brown 已提交
564
			cx->promotion.state = higher;
L
Linus Torvalds 已提交
565 566 567 568 569 570 571 572 573 574 575 576
			cx->promotion.threshold.ticks = cx->latency_ticks;
			if (cx->type >= ACPI_STATE_C2)
				cx->promotion.threshold.count = 4;
			else
				cx->promotion.threshold.count = 10;
			if (higher->type == ACPI_STATE_C3)
				cx->promotion.threshold.bm = bm_history;
		}

		higher = cx;
	}

L
Len Brown 已提交
577
	return_VALUE(0);
L
Linus Torvalds 已提交
578 579
}

L
Len Brown 已提交
580
static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
L
Linus Torvalds 已提交
581 582 583 584 585 586 587 588 589 590 591 592 593
{
	ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_fadt");

	if (!pr)
		return_VALUE(-EINVAL);

	if (!pr->pblk)
		return_VALUE(-ENODEV);

	/* if info is obtained from pblk/fadt, type equals state */
	pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2;
	pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3;

594 595 596 597 598
#ifndef CONFIG_HOTPLUG_CPU
	/*
	 * Check for P_LVL2_UP flag before entering C2 and above on
	 * an SMP system. 
	 */
599
	if ((num_online_cpus() > 1) && !acpi_fadt.plvl2_up)
600 601 602
		return_VALUE(-ENODEV);
#endif

L
Linus Torvalds 已提交
603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618
	/* determine C2 and C3 address from pblk */
	pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4;
	pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5;

	/* determine latencies from FADT */
	pr->power.states[ACPI_STATE_C2].latency = acpi_fadt.plvl2_lat;
	pr->power.states[ACPI_STATE_C3].latency = acpi_fadt.plvl3_lat;

	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
			  "lvl2[0x%08x] lvl3[0x%08x]\n",
			  pr->power.states[ACPI_STATE_C2].address,
			  pr->power.states[ACPI_STATE_C3].address));

	return_VALUE(0);
}

L
Len Brown 已提交
619
static int acpi_processor_get_power_info_default_c1(struct acpi_processor *pr)
620 621 622
{
	ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_default_c1");

623
	/* Zero initialize all the C-states info. */
624
	memset(pr->power.states, 0, sizeof(pr->power.states));
625

626
	/* set the first C-State to C1 */
627 628 629 630 631 632 633 634 635 636
	pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1;

	/* the C0 state only exists as a filler in our array,
	 * and all processors need to support C1 */
	pr->power.states[ACPI_STATE_C0].valid = 1;
	pr->power.states[ACPI_STATE_C1].valid = 1;

	return_VALUE(0);
}

L
Len Brown 已提交
637
static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
L
Linus Torvalds 已提交
638
{
L
Len Brown 已提交
639 640
	acpi_status status = 0;
	acpi_integer count;
641
	int current_count;
L
Len Brown 已提交
642 643 644
	int i;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *cst;
L
Linus Torvalds 已提交
645 646 647 648 649 650

	ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_cst");

	if (nocst)
		return_VALUE(-ENODEV);

651 652 653 654 655 656
	current_count = 1;

	/* Zero initialize C2 onwards and prepare for fresh CST lookup */
	for (i = 2; i < ACPI_PROCESSOR_MAX_POWER; i++)
		memset(&(pr->power.states[i]), 0, 
				sizeof(struct acpi_processor_cx));
L
Linus Torvalds 已提交
657 658 659 660 661

	status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer);
	if (ACPI_FAILURE(status)) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _CST, giving up\n"));
		return_VALUE(-ENODEV);
L
Len Brown 已提交
662
	}
L
Linus Torvalds 已提交
663

L
Len Brown 已提交
664
	cst = (union acpi_object *)buffer.pointer;
L
Linus Torvalds 已提交
665 666 667

	/* There must be at least 2 elements */
	if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) {
L
Len Brown 已提交
668 669
		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
				  "not enough elements in _CST\n"));
L
Linus Torvalds 已提交
670 671 672 673 674 675 676 677
		status = -EFAULT;
		goto end;
	}

	count = cst->package.elements[0].integer.value;

	/* Validate number of power states. */
	if (count < 1 || count != cst->package.count - 1) {
L
Len Brown 已提交
678 679
		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
				  "count given by _CST is not valid\n"));
L
Linus Torvalds 已提交
680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
		status = -EFAULT;
		goto end;
	}

	/* Tell driver that at least _CST is supported. */
	pr->flags.has_cst = 1;

	for (i = 1; i <= count; i++) {
		union acpi_object *element;
		union acpi_object *obj;
		struct acpi_power_register *reg;
		struct acpi_processor_cx cx;

		memset(&cx, 0, sizeof(cx));

L
Len Brown 已提交
695
		element = (union acpi_object *)&(cst->package.elements[i]);
L
Linus Torvalds 已提交
696 697 698 699 700 701
		if (element->type != ACPI_TYPE_PACKAGE)
			continue;

		if (element->package.count != 4)
			continue;

L
Len Brown 已提交
702
		obj = (union acpi_object *)&(element->package.elements[0]);
L
Linus Torvalds 已提交
703 704 705 706

		if (obj->type != ACPI_TYPE_BUFFER)
			continue;

L
Len Brown 已提交
707
		reg = (struct acpi_power_register *)obj->buffer.pointer;
L
Linus Torvalds 已提交
708 709

		if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO &&
L
Len Brown 已提交
710
		    (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE))
L
Linus Torvalds 已提交
711 712 713
			continue;

		cx.address = (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) ?
L
Len Brown 已提交
714
		    0 : reg->address;
L
Linus Torvalds 已提交
715 716

		/* There should be an easy way to extract an integer... */
L
Len Brown 已提交
717
		obj = (union acpi_object *)&(element->package.elements[1]);
L
Linus Torvalds 已提交
718 719 720 721 722 723 724 725 726
		if (obj->type != ACPI_TYPE_INTEGER)
			continue;

		cx.type = obj->integer.value;

		if ((cx.type != ACPI_STATE_C1) &&
		    (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO))
			continue;

727
		if ((cx.type < ACPI_STATE_C2) || (cx.type > ACPI_STATE_C3))
L
Linus Torvalds 已提交
728 729
			continue;

L
Len Brown 已提交
730
		obj = (union acpi_object *)&(element->package.elements[2]);
L
Linus Torvalds 已提交
731 732 733 734 735
		if (obj->type != ACPI_TYPE_INTEGER)
			continue;

		cx.latency = obj->integer.value;

L
Len Brown 已提交
736
		obj = (union acpi_object *)&(element->package.elements[3]);
L
Linus Torvalds 已提交
737 738 739 740 741
		if (obj->type != ACPI_TYPE_INTEGER)
			continue;

		cx.power = obj->integer.value;

742 743 744 745 746 747 748 749 750 751 752 753 754 755 756
		current_count++;
		memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx));

		/*
		 * We support total ACPI_PROCESSOR_MAX_POWER - 1
		 * (From 1 through ACPI_PROCESSOR_MAX_POWER - 1)
		 */
		if (current_count >= (ACPI_PROCESSOR_MAX_POWER - 1)) {
			printk(KERN_WARNING
			       "Limiting number of power states to max (%d)\n",
			       ACPI_PROCESSOR_MAX_POWER);
			printk(KERN_WARNING
			       "Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n");
			break;
		}
L
Linus Torvalds 已提交
757 758
	}

L
Len Brown 已提交
759
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n",
760
			  current_count));
L
Linus Torvalds 已提交
761 762

	/* Validate number of power states discovered */
763
	if (current_count < 2)
764
		status = -EFAULT;
L
Linus Torvalds 已提交
765

L
Len Brown 已提交
766
      end:
L
Linus Torvalds 已提交
767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784
	acpi_os_free(buffer.pointer);

	return_VALUE(status);
}

static void acpi_processor_power_verify_c2(struct acpi_processor_cx *cx)
{
	ACPI_FUNCTION_TRACE("acpi_processor_get_power_verify_c2");

	if (!cx->address)
		return_VOID;

	/*
	 * C2 latency must be less than or equal to 100
	 * microseconds.
	 */
	else if (cx->latency > ACPI_PROCESSOR_MAX_C2_LATENCY) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
785
				  "latency too large [%d]\n", cx->latency));
L
Linus Torvalds 已提交
786 787 788 789 790 791 792 793 794 795 796 797 798
		return_VOID;
	}

	/*
	 * Otherwise we've met all of our C2 requirements.
	 * Normalize the C2 latency to expidite policy
	 */
	cx->valid = 1;
	cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency);

	return_VOID;
}

L
Len Brown 已提交
799 800
static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
					   struct acpi_processor_cx *cx)
L
Linus Torvalds 已提交
801
{
802 803
	static int bm_check_flag;

L
Linus Torvalds 已提交
804 805 806 807 808 809 810 811 812 813 814
	ACPI_FUNCTION_TRACE("acpi_processor_get_power_verify_c3");

	if (!cx->address)
		return_VOID;

	/*
	 * C3 latency must be less than or equal to 1000
	 * microseconds.
	 */
	else if (cx->latency > ACPI_PROCESSOR_MAX_C3_LATENCY) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
815
				  "latency too large [%d]\n", cx->latency));
L
Linus Torvalds 已提交
816 817 818 819 820 821 822 823 824 825 826 827
		return_VOID;
	}

	/*
	 * PIIX4 Erratum #18: We don't support C3 when Type-F (fast)
	 * DMA transfers are used by any ISA device to avoid livelock.
	 * Note that we could disable Type-F DMA (as recommended by
	 * the erratum), but this is known to disrupt certain ISA
	 * devices thus we take the conservative approach.
	 */
	else if (errata.piix4.fdma) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
828
				  "C3 not supported on PIIX4 with Type-F DMA\n"));
L
Linus Torvalds 已提交
829 830 831
		return_VOID;
	}

832 833 834 835 836 837 838 839 840 841 842 843 844
	/* All the logic here assumes flags.bm_check is same across all CPUs */
	if (!bm_check_flag) {
		/* Determine whether bm_check is needed based on CPU  */
		acpi_processor_power_init_bm_check(&(pr->flags), pr->id);
		bm_check_flag = pr->flags.bm_check;
	} else {
		pr->flags.bm_check = bm_check_flag;
	}

	if (pr->flags.bm_check) {
		/* bus mastering control is necessary */
		if (!pr->flags.bm_control) {
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
845
					  "C3 support requires bus mastering control\n"));
846 847 848 849 850 851 852 853 854
			return_VOID;
		}
	} else {
		/*
		 * WBINVD should be set in fadt, for C3 state to be
		 * supported on when bm_check is not required.
		 */
		if (acpi_fadt.wb_invd != 1) {
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
855 856
					  "Cache invalidation should work properly"
					  " for C3 to be enabled on SMP systems\n"));
857 858 859
			return_VOID;
		}
		acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD,
L
Len Brown 已提交
860
				  0, ACPI_MTX_DO_NOT_LOCK);
861 862
	}

L
Linus Torvalds 已提交
863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878
	/*
	 * Otherwise we've met all of our C3 requirements.
	 * Normalize the C3 latency to expidite policy.  Enable
	 * checking of bus mastering status (bm_check) so we can
	 * use this in our C3 policy
	 */
	cx->valid = 1;
	cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency);

	return_VOID;
}

static int acpi_processor_power_verify(struct acpi_processor *pr)
{
	unsigned int i;
	unsigned int working = 0;
879

880
#ifdef ARCH_APICTIMER_STOPS_ON_C3
881 882
	int timer_broadcast = 0;
	cpumask_t mask = cpumask_of_cpu(pr->id);
883
	on_each_cpu(switch_ipi_to_APIC_timer, &mask, 1, 1);
884 885
#endif

L
Len Brown 已提交
886
	for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
L
Linus Torvalds 已提交
887 888 889 890 891 892 893 894 895
		struct acpi_processor_cx *cx = &pr->power.states[i];

		switch (cx->type) {
		case ACPI_STATE_C1:
			cx->valid = 1;
			break;

		case ACPI_STATE_C2:
			acpi_processor_power_verify_c2(cx);
896 897 898 899 900 901 902
#ifdef ARCH_APICTIMER_STOPS_ON_C3
			/* Some AMD systems fake C3 as C2, but still
			   have timer troubles */
			if (cx->valid && 
				boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
				timer_broadcast++;
#endif
L
Linus Torvalds 已提交
903 904 905 906
			break;

		case ACPI_STATE_C3:
			acpi_processor_power_verify_c3(pr, cx);
907
#ifdef ARCH_APICTIMER_STOPS_ON_C3
908 909
			if (cx->valid)
				timer_broadcast++;
910
#endif
L
Linus Torvalds 已提交
911 912 913 914 915 916
			break;
		}

		if (cx->valid)
			working++;
	}
917

918
#ifdef ARCH_APICTIMER_STOPS_ON_C3
919 920
	if (timer_broadcast)
		on_each_cpu(switch_APIC_timer_to_ipi, &mask, 1, 1);
921
#endif
L
Linus Torvalds 已提交
922 923 924 925

	return (working);
}

L
Len Brown 已提交
926
static int acpi_processor_get_power_info(struct acpi_processor *pr)
L
Linus Torvalds 已提交
927 928 929 930 931 932 933 934 935
{
	unsigned int i;
	int result;

	ACPI_FUNCTION_TRACE("acpi_processor_get_power_info");

	/* NOTE: the idle thread may not be running while calling
	 * this function */

936 937
	/* Adding C1 state */
	acpi_processor_get_power_info_default_c1(pr);
L
Linus Torvalds 已提交
938
	result = acpi_processor_get_power_info_cst(pr);
939
	if (result == -ENODEV)
940
		acpi_processor_get_power_info_fadt(pr);
941

942
	pr->power.count = acpi_processor_power_verify(pr);
L
Linus Torvalds 已提交
943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960

	/*
	 * Set Default Policy
	 * ------------------
	 * Now that we know which states are supported, set the default
	 * policy.  Note that this policy can be changed dynamically
	 * (e.g. encourage deeper sleeps to conserve battery life when
	 * not on AC).
	 */
	result = acpi_processor_set_power_policy(pr);
	if (result)
		return_VALUE(result);

	/*
	 * if one state of type C2 or C3 is available, mark this
	 * CPU as being "idle manageable"
	 */
	for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
961
		if (pr->power.states[i].valid) {
L
Linus Torvalds 已提交
962
			pr->power.count = i;
963 964
			if (pr->power.states[i].type >= ACPI_STATE_C2)
				pr->flags.power = 1;
965
		}
L
Linus Torvalds 已提交
966 967 968 969 970
	}

	return_VALUE(0);
}

L
Len Brown 已提交
971
int acpi_processor_cst_has_changed(struct acpi_processor *pr)
L
Linus Torvalds 已提交
972
{
L
Len Brown 已提交
973
	int result = 0;
L
Linus Torvalds 已提交
974 975 976 977

	ACPI_FUNCTION_TRACE("acpi_processor_cst_has_changed");

	if (!pr)
L
Len Brown 已提交
978
		return_VALUE(-EINVAL);
L
Linus Torvalds 已提交
979

L
Len Brown 已提交
980
	if (nocst) {
L
Linus Torvalds 已提交
981 982 983 984 985 986 987 988
		return_VALUE(-ENODEV);
	}

	if (!pr->flags.power_setup_done)
		return_VALUE(-ENODEV);

	/* Fall back to the default idle loop */
	pm_idle = pm_idle_save;
L
Len Brown 已提交
989
	synchronize_sched();	/* Relies on interrupts forcing exit from idle. */
L
Linus Torvalds 已提交
990 991 992 993 994 995 996 997 998 999 1000 1001 1002

	pr->flags.power = 0;
	result = acpi_processor_get_power_info(pr);
	if ((pr->flags.power == 1) && (pr->flags.power_setup_done))
		pm_idle = acpi_processor_idle;

	return_VALUE(result);
}

/* proc interface */

static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
{
L
Len Brown 已提交
1003 1004
	struct acpi_processor *pr = (struct acpi_processor *)seq->private;
	unsigned int i;
L
Linus Torvalds 已提交
1005 1006 1007 1008 1009 1010 1011

	ACPI_FUNCTION_TRACE("acpi_processor_power_seq_show");

	if (!pr)
		goto end;

	seq_printf(seq, "active state:            C%zd\n"
L
Len Brown 已提交
1012 1013 1014 1015
		   "max_cstate:              C%d\n"
		   "bus master activity:     %08x\n",
		   pr->power.state ? pr->power.state - pr->power.states : 0,
		   max_cstate, (unsigned)pr->power.bm_activity);
L
Linus Torvalds 已提交
1016 1017 1018 1019 1020

	seq_puts(seq, "states:\n");

	for (i = 1; i <= pr->power.count; i++) {
		seq_printf(seq, "   %cC%d:                  ",
L
Len Brown 已提交
1021 1022
			   (&pr->power.states[i] ==
			    pr->power.state ? '*' : ' '), i);
L
Linus Torvalds 已提交
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045

		if (!pr->power.states[i].valid) {
			seq_puts(seq, "<not supported>\n");
			continue;
		}

		switch (pr->power.states[i].type) {
		case ACPI_STATE_C1:
			seq_printf(seq, "type[C1] ");
			break;
		case ACPI_STATE_C2:
			seq_printf(seq, "type[C2] ");
			break;
		case ACPI_STATE_C3:
			seq_printf(seq, "type[C3] ");
			break;
		default:
			seq_printf(seq, "type[--] ");
			break;
		}

		if (pr->power.states[i].promotion.state)
			seq_printf(seq, "promotion[C%zd] ",
L
Len Brown 已提交
1046 1047
				   (pr->power.states[i].promotion.state -
				    pr->power.states));
L
Linus Torvalds 已提交
1048 1049 1050 1051 1052
		else
			seq_puts(seq, "promotion[--] ");

		if (pr->power.states[i].demotion.state)
			seq_printf(seq, "demotion[C%zd] ",
L
Len Brown 已提交
1053 1054
				   (pr->power.states[i].demotion.state -
				    pr->power.states));
L
Linus Torvalds 已提交
1055 1056 1057 1058
		else
			seq_puts(seq, "demotion[--] ");

		seq_printf(seq, "latency[%03d] usage[%08d]\n",
L
Len Brown 已提交
1059 1060
			   pr->power.states[i].latency,
			   pr->power.states[i].usage);
L
Linus Torvalds 已提交
1061 1062
	}

L
Len Brown 已提交
1063
      end:
L
Linus Torvalds 已提交
1064 1065 1066 1067 1068 1069
	return_VALUE(0);
}

static int acpi_processor_power_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_processor_power_seq_show,
L
Len Brown 已提交
1070
			   PDE(inode)->data);
L
Linus Torvalds 已提交
1071 1072 1073
}

static struct file_operations acpi_processor_power_fops = {
L
Len Brown 已提交
1074 1075 1076 1077
	.open = acpi_processor_power_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
1078 1079
};

L
Len Brown 已提交
1080 1081
int acpi_processor_power_init(struct acpi_processor *pr,
			      struct acpi_device *device)
L
Linus Torvalds 已提交
1082
{
L
Len Brown 已提交
1083
	acpi_status status = 0;
1084
	static int first_run;
L
Len Brown 已提交
1085
	struct proc_dir_entry *entry = NULL;
L
Linus Torvalds 已提交
1086 1087 1088 1089 1090 1091 1092
	unsigned int i;

	ACPI_FUNCTION_TRACE("acpi_processor_power_init");

	if (!first_run) {
		dmi_check_system(processor_power_dmi_table);
		if (max_cstate < ACPI_C_STATES_MAX)
L
Len Brown 已提交
1093 1094 1095
			printk(KERN_NOTICE
			       "ACPI: processor limited to max C-state %d\n",
			       max_cstate);
L
Linus Torvalds 已提交
1096 1097 1098
		first_run++;
	}

1099 1100 1101 1102
	if (!pr)
		return_VALUE(-EINVAL);

	if (acpi_fadt.cst_cnt && !nocst) {
L
Len Brown 已提交
1103 1104
		status =
		    acpi_os_write_port(acpi_fadt.smi_cmd, acpi_fadt.cst_cnt, 8);
L
Linus Torvalds 已提交
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
		if (ACPI_FAILURE(status)) {
			ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
					  "Notifying BIOS of _CST ability failed\n"));
		}
	}

	acpi_processor_get_power_info(pr);

	/*
	 * Install the idle handler if processor power management is supported.
	 * Note that we use previously set idle handler will be used on
	 * platforms that only support C1.
	 */
	if ((pr->flags.power) && (!boot_option_idle_override)) {
		printk(KERN_INFO PREFIX "CPU%d (power states:", pr->id);
		for (i = 1; i <= pr->power.count; i++)
			if (pr->power.states[i].valid)
L
Len Brown 已提交
1122 1123
				printk(" C%d[C%d]", i,
				       pr->power.states[i].type);
L
Linus Torvalds 已提交
1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
		printk(")\n");

		if (pr->id == 0) {
			pm_idle_save = pm_idle;
			pm_idle = acpi_processor_idle;
		}
	}

	/* 'power' [R] */
	entry = create_proc_entry(ACPI_PROCESSOR_FILE_POWER,
L
Len Brown 已提交
1134
				  S_IRUGO, acpi_device_dir(device));
L
Linus Torvalds 已提交
1135 1136
	if (!entry)
		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
L
Len Brown 已提交
1137 1138
				  "Unable to create '%s' fs entry\n",
				  ACPI_PROCESSOR_FILE_POWER));
L
Linus Torvalds 已提交
1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149
	else {
		entry->proc_fops = &acpi_processor_power_fops;
		entry->data = acpi_driver_data(device);
		entry->owner = THIS_MODULE;
	}

	pr->flags.power_setup_done = 1;

	return_VALUE(0);
}

L
Len Brown 已提交
1150 1151
int acpi_processor_power_exit(struct acpi_processor *pr,
			      struct acpi_device *device)
L
Linus Torvalds 已提交
1152 1153 1154 1155 1156 1157
{
	ACPI_FUNCTION_TRACE("acpi_processor_power_exit");

	pr->flags.power_setup_done = 0;

	if (acpi_device_dir(device))
L
Len Brown 已提交
1158 1159
		remove_proc_entry(ACPI_PROCESSOR_FILE_POWER,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174

	/* Unregister the idle handler when processor #0 is removed. */
	if (pr->id == 0) {
		pm_idle = pm_idle_save;

		/*
		 * We are about to unload the current idle thread pm callback
		 * (pm_idle), Wait for all processors to update cached/local
		 * copies of pm_idle before proceeding.
		 */
		cpu_idle_wait();
	}

	return_VALUE(0);
}