processor_idle.c 33.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5
/*
 * 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>
6
 *  Copyright (C) 2004, 2005 Dominik Brodowski <linux@brodo.de>
L
Linus Torvalds 已提交
7 8
 *  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
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  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>
35
#include <linux/slab.h>
L
Linus Torvalds 已提交
36 37 38
#include <linux/acpi.h>
#include <linux/dmi.h>
#include <linux/moduleparam.h>
T
Tim Schmielau 已提交
39
#include <linux/sched.h>	/* need_resched() */
40
#include <linux/pm_qos.h>
41
#include <linux/clockchips.h>
42
#include <linux/cpuidle.h>
43
#include <linux/irqflags.h>
L
Linus Torvalds 已提交
44

45 46 47 48 49 50 51 52 53 54
/*
 * Include the apic definitions for x86 to have the APIC timer related defines
 * available also for UP (on SMP it gets magically included via linux/smp.h).
 * asm/acpi.h is not an option, as it would require more include magic. Also
 * creating an empty asm-ia64/apic.h would just trade pest vs. cholera.
 */
#ifdef CONFIG_X86
#include <asm/apic.h>
#endif

L
Linus Torvalds 已提交
55 56 57 58 59
#include <asm/io.h>
#include <asm/uaccess.h>

#include <acpi/acpi_bus.h>
#include <acpi/processor.h>
Z
Zhao Yakui 已提交
60
#include <asm/processor.h>
L
Linus Torvalds 已提交
61

62 63
#define PREFIX "ACPI: "

L
Linus Torvalds 已提交
64 65
#define ACPI_PROCESSOR_CLASS            "processor"
#define _COMPONENT              ACPI_PROCESSOR_COMPONENT
66
ACPI_MODULE_NAME("processor_idle");
67
#define PM_TIMER_TICK_NS		(1000000000ULL/PM_TIMER_FREQUENCY)
68 69 70
#define C2_OVERHEAD			1	/* 1us */
#define C3_OVERHEAD			1	/* 1us */
#define PM_TIMER_TICKS_TO_US(p)		(((p) * 1000)/(PM_TIMER_FREQUENCY/1000))
L
Linus Torvalds 已提交
71

72 73
static unsigned int max_cstate __read_mostly = ACPI_PROCESSOR_MAX_POWER;
module_param(max_cstate, uint, 0000);
74
static unsigned int nocst __read_mostly;
L
Linus Torvalds 已提交
75
module_param(nocst, uint, 0000);
76 77
static int bm_check_disable __read_mostly;
module_param(bm_check_disable, uint, 0000);
L
Linus Torvalds 已提交
78

79
static unsigned int latency_factor __read_mostly = 2;
80
module_param(latency_factor, uint, 0644);
L
Linus Torvalds 已提交
81

82 83
static DEFINE_PER_CPU(struct cpuidle_device *, acpi_cpuidle_device);

84 85 86 87 88 89 90
static int disabled_by_idle_boot_param(void)
{
	return boot_option_idle_override == IDLE_POLL ||
		boot_option_idle_override == IDLE_FORCE_MWAIT ||
		boot_option_idle_override == IDLE_HALT;
}

L
Linus Torvalds 已提交
91 92 93 94 95 96
/*
 * 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.
 */
97
static int set_max_cstate(const struct dmi_system_id *id)
L
Linus Torvalds 已提交
98 99 100 101
{
	if (max_cstate > ACPI_PROCESSOR_MAX_POWER)
		return 0;

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

106
	max_cstate = (long)id->driver_data;
L
Linus Torvalds 已提交
107 108 109 110

	return 0;
}

111 112 113
/* 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[] = {
114 115 116
	{ 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 已提交
117
	 (void *)2},
118 119 120 121 122 123 124 125
	{ set_max_cstate, "Pavilion zv5000", {
	  DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
	  DMI_MATCH(DMI_PRODUCT_NAME,"Pavilion zv5000 (DS502A#ABA)")},
	 (void *)1},
	{ set_max_cstate, "Asus L8400B", {
	  DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
	  DMI_MATCH(DMI_PRODUCT_NAME,"L8400B series Notebook PC")},
	 (void *)1},
L
Linus Torvalds 已提交
126 127 128
	{},
};

129

130 131 132 133
/*
 * Callers should disable interrupts before the call and enable
 * interrupts after return.
 */
134 135 136 137 138 139 140 141
static void acpi_safe_halt(void)
{
	current_thread_info()->status &= ~TS_POLLING;
	/*
	 * TS_POLLING-cleared state must be visible before we
	 * test NEED_RESCHED:
	 */
	smp_mb();
142
	if (!need_resched()) {
143
		safe_halt();
144 145
		local_irq_disable();
	}
146 147 148
	current_thread_info()->status |= TS_POLLING;
}

149 150 151 152
#ifdef ARCH_APICTIMER_STOPS_ON_C3

/*
 * Some BIOS implementations switch to C3 in the published C2 state.
153 154 155
 * This seems to be a common problem on AMD boxen, but other vendors
 * are affected too. We pick the most conservative approach: we assume
 * that the local APIC stops in both C2 and C3.
156
 */
157
static void lapic_timer_check_state(int state, struct acpi_processor *pr,
158 159 160
				   struct acpi_processor_cx *cx)
{
	struct acpi_processor_power *pwr = &pr->power;
161
	u8 type = local_apic_timer_c2_ok ? ACPI_STATE_C3 : ACPI_STATE_C2;
162

163 164 165
	if (cpu_has(&cpu_data(pr->id), X86_FEATURE_ARAT))
		return;

166
	if (amd_e400_c1e_detected)
167 168
		type = ACPI_STATE_C1;

169 170 171 172 173 174 175
	/*
	 * Check, if one of the previous states already marked the lapic
	 * unstable
	 */
	if (pwr->timer_broadcast_on_state < state)
		return;

176
	if (cx->type >= type)
177
		pr->power.timer_broadcast_on_state = state;
178 179
}

180
static void __lapic_timer_propagate_broadcast(void *arg)
181
{
182
	struct acpi_processor *pr = (struct acpi_processor *) arg;
183 184 185 186 187 188 189 190
	unsigned long reason;

	reason = pr->power.timer_broadcast_on_state < INT_MAX ?
		CLOCK_EVT_NOTIFY_BROADCAST_ON : CLOCK_EVT_NOTIFY_BROADCAST_OFF;

	clockevents_notify(reason, &pr->id);
}

191 192 193 194 195 196
static void lapic_timer_propagate_broadcast(struct acpi_processor *pr)
{
	smp_call_function_single(pr->id, __lapic_timer_propagate_broadcast,
				 (void *)pr, 1);
}

197
/* Power(C) State timer broadcast control */
198
static void lapic_timer_state_broadcast(struct acpi_processor *pr,
199 200 201 202 203 204 205 206 207 208 209 210
				       struct acpi_processor_cx *cx,
				       int broadcast)
{
	int state = cx - pr->power.states;

	if (state >= pr->power.timer_broadcast_on_state) {
		unsigned long reason;

		reason = broadcast ?  CLOCK_EVT_NOTIFY_BROADCAST_ENTER :
			CLOCK_EVT_NOTIFY_BROADCAST_EXIT;
		clockevents_notify(reason, &pr->id);
	}
211 212 213 214
}

#else

215
static void lapic_timer_check_state(int state, struct acpi_processor *pr,
216
				   struct acpi_processor_cx *cstate) { }
217 218
static void lapic_timer_propagate_broadcast(struct acpi_processor *pr) { }
static void lapic_timer_state_broadcast(struct acpi_processor *pr,
219 220 221 222
				       struct acpi_processor_cx *cx,
				       int broadcast)
{
}
223 224 225

#endif

226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
static u32 saved_bm_rld;

static void acpi_idle_bm_rld_save(void)
{
	acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &saved_bm_rld);
}
static void acpi_idle_bm_rld_restore(void)
{
	u32 resumed_bm_rld;

	acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &resumed_bm_rld);

	if (resumed_bm_rld != saved_bm_rld)
		acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld);
}
241

242
int acpi_processor_suspend(struct device *dev)
243
{
244
	acpi_idle_bm_rld_save();
245 246 247
	return 0;
}

248
int acpi_processor_resume(struct device *dev)
249
{
250
	acpi_idle_bm_rld_restore();
251 252 253
	return 0;
}

J
John Stultz 已提交
254
#if defined(CONFIG_X86)
255
static void tsc_check_state(int state)
256 257 258
{
	switch (boot_cpu_data.x86_vendor) {
	case X86_VENDOR_AMD:
259
	case X86_VENDOR_INTEL:
260 261 262 263
		/*
		 * AMD Fam10h TSC will tick in all
		 * C/P/S0/S1 states when this bit is set.
		 */
264
		if (boot_cpu_has(X86_FEATURE_NONSTOP_TSC))
265
			return;
266

267 268
		/*FALL THROUGH*/
	default:
269 270 271
		/* TSC could halt in idle, so notify users */
		if (state > ACPI_STATE_C1)
			mark_tsc_unstable("TSC halts in idle");
272 273
	}
}
274 275
#else
static void tsc_check_state(int state) { return; }
276 277
#endif

L
Len Brown 已提交
278
static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
L
Linus Torvalds 已提交
279 280 281
{

	if (!pr)
282
		return -EINVAL;
L
Linus Torvalds 已提交
283 284

	if (!pr->pblk)
285
		return -ENODEV;
L
Linus Torvalds 已提交
286 287 288 289 290

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

291 292 293
#ifndef CONFIG_HOTPLUG_CPU
	/*
	 * Check for P_LVL2_UP flag before entering C2 and above on
294
	 * an SMP system.
295
	 */
296
	if ((num_online_cpus() > 1) &&
297
	    !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
298
		return -ENODEV;
299 300
#endif

L
Linus Torvalds 已提交
301 302 303 304 305
	/* 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 */
306 307
	pr->power.states[ACPI_STATE_C2].latency = acpi_gbl_FADT.c2_latency;
	pr->power.states[ACPI_STATE_C3].latency = acpi_gbl_FADT.c3_latency;
L
Linus Torvalds 已提交
308

309 310 311 312
	/*
	 * FADT specified C2 latency must be less than or equal to
	 * 100 microseconds.
	 */
313
	if (acpi_gbl_FADT.c2_latency > ACPI_PROCESSOR_MAX_C2_LATENCY) {
314
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
315
			"C2 latency too large [%d]\n", acpi_gbl_FADT.c2_latency));
316 317 318 319
		/* invalidate C2 */
		pr->power.states[ACPI_STATE_C2].address = 0;
	}

L
Len Brown 已提交
320 321 322 323
	/*
	 * FADT supplied C3 latency must be less than or equal to
	 * 1000 microseconds.
	 */
324
	if (acpi_gbl_FADT.c3_latency > ACPI_PROCESSOR_MAX_C3_LATENCY) {
L
Len Brown 已提交
325
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
326
			"C3 latency too large [%d]\n", acpi_gbl_FADT.c3_latency));
L
Len Brown 已提交
327 328 329 330
		/* invalidate C3 */
		pr->power.states[ACPI_STATE_C3].address = 0;
	}

L
Linus Torvalds 已提交
331 332 333 334 335
	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));

336
	return 0;
L
Linus Torvalds 已提交
337 338
}

339
static int acpi_processor_get_power_info_default(struct acpi_processor *pr)
340
{
341 342 343 344 345
	if (!pr->power.states[ACPI_STATE_C1].valid) {
		/* set the first C-State to C1 */
		/* all processors need to support C1 */
		pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1;
		pr->power.states[ACPI_STATE_C1].valid = 1;
346
		pr->power.states[ACPI_STATE_C1].entry_method = ACPI_CSTATE_HALT;
347 348
	}
	/* the C0 state only exists as a filler in our array */
349
	pr->power.states[ACPI_STATE_C0].valid = 1;
350
	return 0;
351 352
}

L
Len Brown 已提交
353
static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
L
Linus Torvalds 已提交
354
{
L
Len Brown 已提交
355
	acpi_status status = 0;
L
Lin Ming 已提交
356
	u64 count;
357
	int current_count;
L
Len Brown 已提交
358 359 360
	int i;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *cst;
L
Linus Torvalds 已提交
361 362 363


	if (nocst)
364
		return -ENODEV;
L
Linus Torvalds 已提交
365

366
	current_count = 0;
L
Linus Torvalds 已提交
367 368 369 370

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

374
	cst = buffer.pointer;
L
Linus Torvalds 已提交
375 376 377

	/* There must be at least 2 elements */
	if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) {
378
		printk(KERN_ERR PREFIX "not enough elements in _CST\n");
L
Linus Torvalds 已提交
379 380 381 382 383 384 385 386
		status = -EFAULT;
		goto end;
	}

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

	/* Validate number of power states. */
	if (count < 1 || count != cst->package.count - 1) {
387
		printk(KERN_ERR PREFIX "count given by _CST is not valid\n");
L
Linus Torvalds 已提交
388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
		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));

403
		element = &(cst->package.elements[i]);
L
Linus Torvalds 已提交
404 405 406 407 408 409
		if (element->type != ACPI_TYPE_PACKAGE)
			continue;

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

410
		obj = &(element->package.elements[0]);
L
Linus Torvalds 已提交
411 412 413 414

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

L
Len Brown 已提交
415
		reg = (struct acpi_power_register *)obj->buffer.pointer;
L
Linus Torvalds 已提交
416 417

		if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO &&
L
Len Brown 已提交
418
		    (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE))
L
Linus Torvalds 已提交
419 420 421
			continue;

		/* There should be an easy way to extract an integer... */
422
		obj = &(element->package.elements[1]);
L
Linus Torvalds 已提交
423 424 425 426
		if (obj->type != ACPI_TYPE_INTEGER)
			continue;

		cx.type = obj->integer.value;
427 428 429 430 431 432 433 434 435 436
		/*
		 * Some buggy BIOSes won't list C1 in _CST -
		 * Let acpi_processor_get_power_info_default() handle them later
		 */
		if (i == 1 && cx.type != ACPI_STATE_C1)
			current_count++;

		cx.address = reg->address;
		cx.index = current_count + 1;

437
		cx.entry_method = ACPI_CSTATE_SYSTEMIO;
438 439 440
		if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
			if (acpi_processor_ffh_cstate_probe
					(pr->id, &cx, reg) == 0) {
441 442
				cx.entry_method = ACPI_CSTATE_FFH;
			} else if (cx.type == ACPI_STATE_C1) {
443 444 445 446 447 448
				/*
				 * C1 is a special case where FIXED_HARDWARE
				 * can be handled in non-MWAIT way as well.
				 * In that case, save this _CST entry info.
				 * Otherwise, ignore this info and continue.
				 */
449
				cx.entry_method = ACPI_CSTATE_HALT;
450
				snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
451
			} else {
452 453
				continue;
			}
454
			if (cx.type == ACPI_STATE_C1 &&
455
			    (boot_option_idle_override == IDLE_NOMWAIT)) {
Z
Zhao Yakui 已提交
456 457 458 459 460 461
				/*
				 * In most cases the C1 space_id obtained from
				 * _CST object is FIXED_HARDWARE access mode.
				 * But when the option of idle=halt is added,
				 * the entry_method type should be changed from
				 * CSTATE_FFH to CSTATE_HALT.
462 463 464
				 * When the option of idle=nomwait is added,
				 * the C1 entry_method type should be
				 * CSTATE_HALT.
Z
Zhao Yakui 已提交
465 466 467 468
				 */
				cx.entry_method = ACPI_CSTATE_HALT;
				snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
			}
469 470 471
		} else {
			snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI IOPORT 0x%x",
				 cx.address);
472
		}
L
Linus Torvalds 已提交
473

474 475 476
		if (cx.type == ACPI_STATE_C1) {
			cx.valid = 1;
		}
477

478
		obj = &(element->package.elements[2]);
L
Linus Torvalds 已提交
479 480 481 482 483
		if (obj->type != ACPI_TYPE_INTEGER)
			continue;

		cx.latency = obj->integer.value;

484
		obj = &(element->package.elements[3]);
L
Linus Torvalds 已提交
485 486 487
		if (obj->type != ACPI_TYPE_INTEGER)
			continue;

488 489 490 491 492 493 494 495 496 497 498 499 500 501 502
		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 已提交
503 504
	}

L
Len Brown 已提交
505
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n",
506
			  current_count));
L
Linus Torvalds 已提交
507 508

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

L
Len Brown 已提交
512
      end:
513
	kfree(buffer.pointer);
L
Linus Torvalds 已提交
514

515
	return status;
L
Linus Torvalds 已提交
516 517
}

L
Len Brown 已提交
518 519
static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
					   struct acpi_processor_cx *cx)
L
Linus Torvalds 已提交
520
{
521 522
	static int bm_check_flag = -1;
	static int bm_control_flag = -1;
523

L
Linus Torvalds 已提交
524 525

	if (!cx->address)
526
		return;
L
Linus Torvalds 已提交
527 528 529 530 531 532 533 534 535 536

	/*
	 * 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 已提交
537
				  "C3 not supported on PIIX4 with Type-F DMA\n"));
538
		return;
L
Linus Torvalds 已提交
539 540
	}

541
	/* All the logic here assumes flags.bm_check is same across all CPUs */
542
	if (bm_check_flag == -1) {
543 544 545
		/* 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;
546
		bm_control_flag = pr->flags.bm_control;
547 548
	} else {
		pr->flags.bm_check = bm_check_flag;
549
		pr->flags.bm_control = bm_control_flag;
550 551 552 553
	}

	if (pr->flags.bm_check) {
		if (!pr->flags.bm_control) {
554 555 556 557 558 559 560 561 562 563
			if (pr->flags.has_cst != 1) {
				/* bus mastering control is necessary */
				ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					"C3 support requires BM control\n"));
				return;
			} else {
				/* Here we enter C3 without bus mastering */
				ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					"C3 support without BM control\n"));
			}
564 565 566 567 568 569
		}
	} else {
		/*
		 * WBINVD should be set in fadt, for C3 state to be
		 * supported on when bm_check is not required.
		 */
570
		if (!(acpi_gbl_FADT.flags & ACPI_FADT_WBINVD)) {
571
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
572 573
					  "Cache invalidation should work properly"
					  " for C3 to be enabled on SMP systems\n"));
574
			return;
575 576 577
		}
	}

L
Linus Torvalds 已提交
578 579 580 581 582 583 584
	/*
	 * 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;
585

586 587 588 589 590 591 592 593
	/*
	 * On older chipsets, BM_RLD needs to be set
	 * in order for Bus Master activity to wake the
	 * system from C3.  Newer chipsets handle DMA
	 * during C3 automatically and BM_RLD is a NOP.
	 * In either case, the proper way to
	 * handle BM_RLD is to set it and leave it set.
	 */
594
	acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, 1);
L
Linus Torvalds 已提交
595

596
	return;
L
Linus Torvalds 已提交
597 598 599 600 601 602
}

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

604
	pr->power.timer_broadcast_on_state = INT_MAX;
605

606
	for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
L
Linus Torvalds 已提交
607 608 609 610 611 612 613 614
		struct acpi_processor_cx *cx = &pr->power.states[i];

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

		case ACPI_STATE_C2:
615 616 617
			if (!cx->address)
				break;
			cx->valid = 1; 
L
Linus Torvalds 已提交
618 619 620 621 622 623
			break;

		case ACPI_STATE_C3:
			acpi_processor_power_verify_c3(pr, cx);
			break;
		}
624 625
		if (!cx->valid)
			continue;
L
Linus Torvalds 已提交
626

627 628 629
		lapic_timer_check_state(i, pr, cx);
		tsc_check_state(cx->type);
		working++;
L
Linus Torvalds 已提交
630
	}
631

632
	lapic_timer_propagate_broadcast(pr);
L
Linus Torvalds 已提交
633 634 635 636

	return (working);
}

L
Len Brown 已提交
637
static int acpi_processor_get_power_info(struct acpi_processor *pr)
L
Linus Torvalds 已提交
638 639 640 641 642 643 644 645
{
	unsigned int i;
	int result;


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

646 647 648
	/* Zero initialize all the C-states info. */
	memset(pr->power.states, 0, sizeof(pr->power.states));

L
Linus Torvalds 已提交
649
	result = acpi_processor_get_power_info_cst(pr);
650
	if (result == -ENODEV)
651
		result = acpi_processor_get_power_info_fadt(pr);
652

653 654 655 656 657
	if (result)
		return result;

	acpi_processor_get_power_info_default(pr);

658
	pr->power.count = acpi_processor_power_verify(pr);
L
Linus Torvalds 已提交
659 660 661 662 663 664

	/*
	 * 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++) {
665
		if (pr->power.states[i].valid) {
L
Linus Torvalds 已提交
666
			pr->power.count = i;
667 668
			if (pr->power.states[i].type >= ACPI_STATE_C2)
				pr->flags.power = 1;
669
		}
L
Linus Torvalds 已提交
670 671
	}

672
	return 0;
L
Linus Torvalds 已提交
673 674
}

675 676 677 678 679 680 681
/**
 * acpi_idle_bm_check - checks if bus master activity was detected
 */
static int acpi_idle_bm_check(void)
{
	u32 bm_status = 0;

682 683 684
	if (bm_check_disable)
		return 0;

685
	acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, &bm_status);
686
	if (bm_status)
687
		acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, 1);
688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703
	/*
	 * 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)
		    || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01))
			bm_status = 1;
	}
	return bm_status;
}

/**
 * acpi_idle_do_entry - a helper function that does C2 and C3 type entry
 * @cx: cstate data
704 705
 *
 * Caller disables interrupt before call and enables interrupt after return.
706 707 708
 */
static inline void acpi_idle_do_entry(struct acpi_processor_cx *cx)
{
709 710
	/* Don't trace irqs off for idle */
	stop_critical_timings();
711
	if (cx->entry_method == ACPI_CSTATE_FFH) {
712 713
		/* Call into architectural FFH based C-state */
		acpi_processor_ffh_cstate_enter(cx);
714 715
	} else if (cx->entry_method == ACPI_CSTATE_HALT) {
		acpi_safe_halt();
716 717 718 719 720 721
	} else {
		/* IO port based C-state */
		inb(cx->address);
		/* Dummy wait op - must do something useless after P_LVL2 read
		   because chipsets cannot guarantee that STPCLK# signal
		   gets asserted in time to freeze execution properly. */
722
		inl(acpi_gbl_FADT.xpm_timer_block.address);
723
	}
724
	start_critical_timings();
725 726 727 728 729
}

/**
 * acpi_idle_enter_c1 - enters an ACPI C1 state-type
 * @dev: the target CPU
730
 * @drv: cpuidle driver containing cpuidle state info
731
 * @index: index of target state
732 733 734 735
 *
 * This is equivalent to the HALT instruction.
 */
static int acpi_idle_enter_c1(struct cpuidle_device *dev,
736
		struct cpuidle_driver *drv, int index)
737
{
738 739
	ktime_t  kt1, kt2;
	s64 idle_time;
740
	struct acpi_processor *pr;
741 742
	struct cpuidle_state_usage *state_usage = &dev->states_usage[index];
	struct acpi_processor_cx *cx = cpuidle_get_statedata(state_usage);
743

744
	pr = __this_cpu_read(processors);
745
	dev->last_residency = 0;
746 747

	if (unlikely(!pr))
748
		return -EINVAL;
749

750
	local_irq_disable();
751

752

753
	lapic_timer_state_broadcast(pr, cx, 1);
754
	kt1 = ktime_get_real();
755
	acpi_idle_do_entry(cx);
756 757
	kt2 = ktime_get_real();
	idle_time =  ktime_to_us(ktime_sub(kt2, kt1));
758

759 760 761
	/* Update device last_residency*/
	dev->last_residency = (int)idle_time;

762
	local_irq_enable();
763
	lapic_timer_state_broadcast(pr, cx, 0);
764

765
	return index;
766 767
}

768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783

/**
 * acpi_idle_play_dead - enters an ACPI state for long-term idle (i.e. off-lining)
 * @dev: the target CPU
 * @index: the index of suggested state
 */
static int acpi_idle_play_dead(struct cpuidle_device *dev, int index)
{
	struct cpuidle_state_usage *state_usage = &dev->states_usage[index];
	struct acpi_processor_cx *cx = cpuidle_get_statedata(state_usage);

	ACPI_FLUSH_CPU_CACHE();

	while (1) {

		if (cx->entry_method == ACPI_CSTATE_HALT)
784
			safe_halt();
785 786 787 788 789 790 791 792 793 794 795 796
		else if (cx->entry_method == ACPI_CSTATE_SYSTEMIO) {
			inb(cx->address);
			/* See comment in acpi_idle_do_entry() */
			inl(acpi_gbl_FADT.xpm_timer_block.address);
		} else
			return -ENODEV;
	}

	/* Never reached */
	return 0;
}

797 798 799
/**
 * acpi_idle_enter_simple - enters an ACPI state without BM handling
 * @dev: the target CPU
800
 * @drv: cpuidle driver with cpuidle state information
801
 * @index: the index of suggested state
802 803
 */
static int acpi_idle_enter_simple(struct cpuidle_device *dev,
804
		struct cpuidle_driver *drv, int index)
805 806
{
	struct acpi_processor *pr;
807 808
	struct cpuidle_state_usage *state_usage = &dev->states_usage[index];
	struct acpi_processor_cx *cx = cpuidle_get_statedata(state_usage);
809
	ktime_t  kt1, kt2;
810
	s64 idle_time_ns;
811
	s64 idle_time;
812

813
	pr = __this_cpu_read(processors);
814
	dev->last_residency = 0;
815 816

	if (unlikely(!pr))
817
		return -EINVAL;
818

819
	local_irq_disable();
820

821

822 823 824 825 826 827 828
	if (cx->entry_method != ACPI_CSTATE_FFH) {
		current_thread_info()->status &= ~TS_POLLING;
		/*
		 * TS_POLLING-cleared state must be visible before we test
		 * NEED_RESCHED:
		 */
		smp_mb();
829

830 831 832
		if (unlikely(need_resched())) {
			current_thread_info()->status |= TS_POLLING;
			local_irq_enable();
833
			return -EINVAL;
834
		}
835 836
	}

837 838 839 840
	/*
	 * Must be done before busmaster disable as we might need to
	 * access HPET !
	 */
841
	lapic_timer_state_broadcast(pr, cx, 1);
842

843 844 845
	if (cx->type == ACPI_STATE_C3)
		ACPI_FLUSH_CPU_CACHE();

846
	kt1 = ktime_get_real();
847 848
	/* Tell the scheduler that we are going deep-idle: */
	sched_clock_idle_sleep_event();
849
	acpi_idle_do_entry(cx);
850
	kt2 = ktime_get_real();
851 852 853
	idle_time_ns = ktime_to_ns(ktime_sub(kt2, kt1));
	idle_time = idle_time_ns;
	do_div(idle_time, NSEC_PER_USEC);
854

855 856 857
	/* Update device last_residency*/
	dev->last_residency = (int)idle_time;

858
	/* Tell the scheduler how much we idled: */
859
	sched_clock_idle_wakeup_event(idle_time_ns);
860 861

	local_irq_enable();
862 863
	if (cx->entry_method != ACPI_CSTATE_FFH)
		current_thread_info()->status |= TS_POLLING;
864

865
	lapic_timer_state_broadcast(pr, cx, 0);
866
	return index;
867 868 869
}

static int c3_cpu_count;
870
static DEFINE_RAW_SPINLOCK(c3_lock);
871 872 873 874

/**
 * acpi_idle_enter_bm - enters C3 with proper BM handling
 * @dev: the target CPU
875
 * @drv: cpuidle driver containing state data
876
 * @index: the index of suggested state
877 878 879 880
 *
 * If BM is detected, the deepest non-C3 idle state is entered instead.
 */
static int acpi_idle_enter_bm(struct cpuidle_device *dev,
881
		struct cpuidle_driver *drv, int index)
882 883
{
	struct acpi_processor *pr;
884 885
	struct cpuidle_state_usage *state_usage = &dev->states_usage[index];
	struct acpi_processor_cx *cx = cpuidle_get_statedata(state_usage);
886
	ktime_t  kt1, kt2;
887
	s64 idle_time_ns;
888 889
	s64 idle_time;

890

891
	pr = __this_cpu_read(processors);
892
	dev->last_residency = 0;
893 894

	if (unlikely(!pr))
895
		return -EINVAL;
896

897
	if (!cx->bm_sts_skip && acpi_idle_bm_check()) {
898 899 900
		if (drv->safe_state_index >= 0) {
			return drv->states[drv->safe_state_index].enter(dev,
						drv, drv->safe_state_index);
901
		} else {
902
			local_irq_disable();
903
			acpi_safe_halt();
904
			local_irq_enable();
905
			return -EBUSY;
906 907 908
		}
	}

909
	local_irq_disable();
910

911

912 913 914 915 916 917 918
	if (cx->entry_method != ACPI_CSTATE_FFH) {
		current_thread_info()->status &= ~TS_POLLING;
		/*
		 * TS_POLLING-cleared state must be visible before we test
		 * NEED_RESCHED:
		 */
		smp_mb();
919

920 921 922
		if (unlikely(need_resched())) {
			current_thread_info()->status |= TS_POLLING;
			local_irq_enable();
923
			return -EINVAL;
924
		}
925 926
	}

927 928
	acpi_unlazy_tlb(smp_processor_id());

929 930
	/* Tell the scheduler that we are going deep-idle: */
	sched_clock_idle_sleep_event();
931 932 933 934
	/*
	 * Must be done before busmaster disable as we might need to
	 * access HPET !
	 */
935
	lapic_timer_state_broadcast(pr, cx, 1);
936

937
	kt1 = ktime_get_real();
938 939 940 941 942 943 944 945 946 947 948
	/*
	 * disable bus master
	 * bm_check implies we need ARB_DIS
	 * !bm_check implies we need cache flush
	 * bm_control implies whether we can do ARB_DIS
	 *
	 * That leaves a case where bm_check is set and bm_control is
	 * not set. In that case we cannot do much, we enter C3
	 * without doing anything.
	 */
	if (pr->flags.bm_check && pr->flags.bm_control) {
949
		raw_spin_lock(&c3_lock);
950 951 952
		c3_cpu_count++;
		/* Disable bus master arbitration when all CPUs are in C3 */
		if (c3_cpu_count == num_online_cpus())
953
			acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 1);
954
		raw_spin_unlock(&c3_lock);
955 956 957
	} else if (!pr->flags.bm_check) {
		ACPI_FLUSH_CPU_CACHE();
	}
958

959
	acpi_idle_do_entry(cx);
960

961 962
	/* Re-enable bus master arbitration */
	if (pr->flags.bm_check && pr->flags.bm_control) {
963
		raw_spin_lock(&c3_lock);
964
		acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 0);
965
		c3_cpu_count--;
966
		raw_spin_unlock(&c3_lock);
967
	}
968
	kt2 = ktime_get_real();
969
	idle_time_ns = ktime_to_ns(ktime_sub(kt2, kt1));
970 971
	idle_time = idle_time_ns;
	do_div(idle_time, NSEC_PER_USEC);
972

973 974 975
	/* Update device last_residency*/
	dev->last_residency = (int)idle_time;

976
	/* Tell the scheduler how much we idled: */
977
	sched_clock_idle_wakeup_event(idle_time_ns);
978 979

	local_irq_enable();
980 981
	if (cx->entry_method != ACPI_CSTATE_FFH)
		current_thread_info()->status |= TS_POLLING;
982

983
	lapic_timer_state_broadcast(pr, cx, 0);
984
	return index;
985 986 987 988 989 990 991 992
}

struct cpuidle_driver acpi_idle_driver = {
	.name =		"acpi_idle",
	.owner =	THIS_MODULE,
};

/**
993 994 995
 * acpi_processor_setup_cpuidle_cx - prepares and configures CPUIDLE
 * device i.e. per-cpu data
 *
996 997
 * @pr: the ACPI processor
 */
998
static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr)
999
{
1000
	int i, count = CPUIDLE_DRIVER_STATE_START;
1001
	struct acpi_processor_cx *cx;
1002
	struct cpuidle_state_usage *state_usage;
1003
	struct cpuidle_device *dev = per_cpu(acpi_cpuidle_device, pr->id);
1004 1005 1006 1007 1008 1009 1010 1011

	if (!pr->flags.power_setup_done)
		return -EINVAL;

	if (pr->flags.power == 0) {
		return -EINVAL;
	}

1012
	dev->cpu = pr->id;
1013

1014 1015 1016
	if (max_cstate == 0)
		max_cstate = 1;

1017 1018
	for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
		cx = &pr->power.states[i];
1019
		state_usage = &dev->states_usage[count];
1020 1021 1022 1023 1024 1025 1026 1027 1028

		if (!cx->valid)
			continue;

#ifdef CONFIG_HOTPLUG_CPU
		if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) &&
		    !pr->flags.has_cst &&
		    !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
			continue;
1029
#endif
1030

1031
		cpuidle_set_statedata(state_usage, cx);
1032

1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
		count++;
		if (count == CPUIDLE_STATE_MAX)
			break;
	}

	dev->state_count = count;

	if (!count)
		return -EINVAL;

	return 0;
}

/**
 * acpi_processor_setup_cpuidle states- prepares and configures cpuidle
 * global state data i.e. idle routines
 *
 * @pr: the ACPI processor
 */
static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr)
{
	int i, count = CPUIDLE_DRIVER_STATE_START;
	struct acpi_processor_cx *cx;
	struct cpuidle_state *state;
	struct cpuidle_driver *drv = &acpi_idle_driver;

	if (!pr->flags.power_setup_done)
		return -EINVAL;

	if (pr->flags.power == 0)
		return -EINVAL;

	drv->safe_state_index = -1;
1066
	for (i = 0; i < CPUIDLE_STATE_MAX; i++) {
1067 1068
		drv->states[i].name[0] = '\0';
		drv->states[i].desc[0] = '\0';
1069 1070
	}

1071 1072 1073
	if (max_cstate == 0)
		max_cstate = 1;

1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
	for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
		cx = &pr->power.states[i];

		if (!cx->valid)
			continue;

#ifdef CONFIG_HOTPLUG_CPU
		if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) &&
		    !pr->flags.has_cst &&
		    !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
			continue;
1085
#endif
1086

1087
		state = &drv->states[count];
1088
		snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i);
1089
		strncpy(state->desc, cx->desc, CPUIDLE_DESC_LEN);
1090
		state->exit_latency = cx->latency;
1091
		state->target_residency = cx->latency * latency_factor;
1092 1093 1094 1095

		state->flags = 0;
		switch (cx->type) {
			case ACPI_STATE_C1:
1096 1097 1098
			if (cx->entry_method == ACPI_CSTATE_FFH)
				state->flags |= CPUIDLE_FLAG_TIME_VALID;

1099
			state->enter = acpi_idle_enter_c1;
1100
			state->enter_dead = acpi_idle_play_dead;
1101
			drv->safe_state_index = count;
1102 1103 1104 1105 1106
			break;

			case ACPI_STATE_C2:
			state->flags |= CPUIDLE_FLAG_TIME_VALID;
			state->enter = acpi_idle_enter_simple;
1107
			state->enter_dead = acpi_idle_play_dead;
1108
			drv->safe_state_index = count;
1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
			break;

			case ACPI_STATE_C3:
			state->flags |= CPUIDLE_FLAG_TIME_VALID;
			state->enter = pr->flags.bm_check ?
					acpi_idle_enter_bm :
					acpi_idle_enter_simple;
			break;
		}

		count++;
1120 1121
		if (count == CPUIDLE_STATE_MAX)
			break;
1122 1123
	}

1124
	drv->state_count = count;
1125 1126 1127 1128 1129 1130 1131

	if (!count)
		return -EINVAL;

	return 0;
}

1132
int acpi_processor_hotplug(struct acpi_processor *pr)
1133
{
1134
	int ret = 0;
1135
	struct cpuidle_device *dev;
1136

1137
	if (disabled_by_idle_boot_param())
1138 1139
		return 0;

1140 1141 1142 1143 1144 1145 1146 1147 1148 1149
	if (!pr)
		return -EINVAL;

	if (nocst) {
		return -ENODEV;
	}

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

1150
	dev = per_cpu(acpi_cpuidle_device, pr->id);
1151
	cpuidle_pause_and_lock();
1152
	cpuidle_disable_device(dev);
1153
	acpi_processor_get_power_info(pr);
1154
	if (pr->flags.power) {
1155
		acpi_processor_setup_cpuidle_cx(pr);
1156
		ret = cpuidle_enable_device(dev);
1157
	}
1158 1159 1160 1161 1162
	cpuidle_resume_and_unlock();

	return ret;
}

1163 1164 1165 1166
int acpi_processor_cst_has_changed(struct acpi_processor *pr)
{
	int cpu;
	struct acpi_processor *_pr;
1167
	struct cpuidle_device *dev;
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186

	if (disabled_by_idle_boot_param())
		return 0;

	if (!pr)
		return -EINVAL;

	if (nocst)
		return -ENODEV;

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

	/*
	 * FIXME:  Design the ACPI notification to make it once per
	 * system instead of once per-cpu.  This condition is a hack
	 * to make the code that updates C-States be called once.
	 */

1187
	if (pr->id == 0 && cpuidle_get_driver() == &acpi_idle_driver) {
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197

		cpuidle_pause_and_lock();
		/* Protect against cpu-hotplug */
		get_online_cpus();

		/* Disable all cpuidle devices */
		for_each_online_cpu(cpu) {
			_pr = per_cpu(processors, cpu);
			if (!_pr || !_pr->flags.power_setup_done)
				continue;
1198 1199
			dev = per_cpu(acpi_cpuidle_device, cpu);
			cpuidle_disable_device(dev);
1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
		}

		/* Populate Updated C-state information */
		acpi_processor_setup_cpuidle_states(pr);

		/* Enable all cpuidle devices */
		for_each_online_cpu(cpu) {
			_pr = per_cpu(processors, cpu);
			if (!_pr || !_pr->flags.power_setup_done)
				continue;
			acpi_processor_get_power_info(_pr);
			if (_pr->flags.power) {
				acpi_processor_setup_cpuidle_cx(_pr);
1213 1214
				dev = per_cpu(acpi_cpuidle_device, cpu);
				cpuidle_enable_device(dev);
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
			}
		}
		put_online_cpus();
		cpuidle_resume_and_unlock();
	}

	return 0;
}

static int acpi_processor_registered;

1226
int __cpuinit acpi_processor_power_init(struct acpi_processor *pr)
L
Linus Torvalds 已提交
1227
{
L
Len Brown 已提交
1228
	acpi_status status = 0;
1229
	int retval;
1230
	struct cpuidle_device *dev;
1231
	static int first_run;
L
Linus Torvalds 已提交
1232

1233
	if (disabled_by_idle_boot_param())
1234
		return 0;
L
Linus Torvalds 已提交
1235 1236 1237

	if (!first_run) {
		dmi_check_system(processor_power_dmi_table);
1238
		max_cstate = acpi_processor_cstate_check(max_cstate);
L
Linus Torvalds 已提交
1239
		if (max_cstate < ACPI_C_STATES_MAX)
L
Len Brown 已提交
1240 1241 1242
			printk(KERN_NOTICE
			       "ACPI: processor limited to max C-state %d\n",
			       max_cstate);
L
Linus Torvalds 已提交
1243 1244 1245
		first_run++;
	}

1246
	if (!pr)
1247
		return -EINVAL;
1248

1249
	if (acpi_gbl_FADT.cst_control && !nocst) {
L
Len Brown 已提交
1250
		status =
1251
		    acpi_os_write_port(acpi_gbl_FADT.smi_command, acpi_gbl_FADT.cst_control, 8);
L
Linus Torvalds 已提交
1252
		if (ACPI_FAILURE(status)) {
1253 1254
			ACPI_EXCEPTION((AE_INFO, status,
					"Notifying BIOS of _CST ability failed"));
L
Linus Torvalds 已提交
1255 1256 1257 1258
		}
	}

	acpi_processor_get_power_info(pr);
1259
	pr->flags.power_setup_done = 1;
L
Linus Torvalds 已提交
1260 1261 1262 1263 1264 1265

	/*
	 * 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.
	 */
1266
	if (pr->flags.power) {
1267 1268 1269 1270 1271 1272 1273 1274 1275
		/* Register acpi_idle_driver if not already registered */
		if (!acpi_processor_registered) {
			acpi_processor_setup_cpuidle_states(pr);
			retval = cpuidle_register_driver(&acpi_idle_driver);
			if (retval)
				return retval;
			printk(KERN_DEBUG "ACPI: %s registered with cpuidle\n",
					acpi_idle_driver.name);
		}
1276 1277 1278 1279 1280 1281 1282 1283

		dev = kzalloc(sizeof(*dev), GFP_KERNEL);
		if (!dev)
			return -ENOMEM;
		per_cpu(acpi_cpuidle_device, pr->id) = dev;

		acpi_processor_setup_cpuidle_cx(pr);

1284 1285 1286
		/* Register per-cpu cpuidle_device. Cpuidle driver
		 * must already be registered before registering device
		 */
1287
		retval = cpuidle_register_device(dev);
1288 1289 1290 1291 1292 1293
		if (retval) {
			if (acpi_processor_registered == 0)
				cpuidle_unregister_driver(&acpi_idle_driver);
			return retval;
		}
		acpi_processor_registered++;
L
Linus Torvalds 已提交
1294
	}
1295
	return 0;
L
Linus Torvalds 已提交
1296 1297
}

1298
int acpi_processor_power_exit(struct acpi_processor *pr)
L
Linus Torvalds 已提交
1299
{
1300 1301
	struct cpuidle_device *dev = per_cpu(acpi_cpuidle_device, pr->id);

1302
	if (disabled_by_idle_boot_param())
1303 1304
		return 0;

1305
	if (pr->flags.power) {
1306
		cpuidle_unregister_device(dev);
1307 1308 1309 1310
		acpi_processor_registered--;
		if (acpi_processor_registered == 0)
			cpuidle_unregister_driver(&acpi_idle_driver);
	}
L
Linus Torvalds 已提交
1311

1312
	pr->flags.power_setup_done = 0;
1313
	return 0;
L
Linus Torvalds 已提交
1314
}