1 /* 2 * processor_idle - idle state submodule to the ACPI processor driver 3 * 4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 6 * Copyright (C) 2004, 2005 Dominik Brodowski <linux@brodo.de> 7 * Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com> 8 * - Added processor hotplug support 9 * Copyright (C) 2005 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com> 10 * - Added support for C3 on SMP 11 * 12 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 13 * 14 * This program is free software; you can redistribute it and/or modify 15 * it under the terms of the GNU General Public License as published by 16 * the Free Software Foundation; either version 2 of the License, or (at 17 * your option) any later version. 18 * 19 * This program is distributed in the hope that it will be useful, but 20 * WITHOUT ANY WARRANTY; without even the implied warranty of 21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 22 * General Public License for more details. 23 * 24 * You should have received a copy of the GNU General Public License along 25 * with this program; if not, write to the Free Software Foundation, Inc., 26 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 27 * 28 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 29 */ 30 31 #include <linux/kernel.h> 32 #include <linux/module.h> 33 #include <linux/init.h> 34 #include <linux/cpufreq.h> 35 #include <linux/proc_fs.h> 36 #include <linux/seq_file.h> 37 #include <linux/acpi.h> 38 #include <linux/dmi.h> 39 #include <linux/moduleparam.h> 40 #include <linux/sched.h> /* need_resched() */ 41 #include <linux/latency.h> 42 43 #include <asm/io.h> 44 #include <asm/uaccess.h> 45 46 #include <acpi/acpi_bus.h> 47 #include <acpi/processor.h> 48 49 #define ACPI_PROCESSOR_COMPONENT 0x01000000 50 #define ACPI_PROCESSOR_CLASS "processor" 51 #define ACPI_PROCESSOR_DRIVER_NAME "ACPI Processor Driver" 52 #define _COMPONENT ACPI_PROCESSOR_COMPONENT 53 ACPI_MODULE_NAME("acpi_processor") 54 #define ACPI_PROCESSOR_FILE_POWER "power" 55 #define US_TO_PM_TIMER_TICKS(t) ((t * (PM_TIMER_FREQUENCY/1000)) / 1000) 56 #define C2_OVERHEAD 4 /* 1us (3.579 ticks per us) */ 57 #define C3_OVERHEAD 4 /* 1us (3.579 ticks per us) */ 58 static void (*pm_idle_save) (void) __read_mostly; 59 module_param(max_cstate, uint, 0644); 60 61 static unsigned int nocst __read_mostly; 62 module_param(nocst, uint, 0000); 63 64 /* 65 * bm_history -- bit-mask with a bit per jiffy of bus-master activity 66 * 1000 HZ: 0xFFFFFFFF: 32 jiffies = 32ms 67 * 800 HZ: 0xFFFFFFFF: 32 jiffies = 40ms 68 * 100 HZ: 0x0000000F: 4 jiffies = 40ms 69 * reduce history for more aggressive entry into C3 70 */ 71 static unsigned int bm_history __read_mostly = 72 (HZ >= 800 ? 0xFFFFFFFF : ((1U << (HZ / 25)) - 1)); 73 module_param(bm_history, uint, 0644); 74 /* -------------------------------------------------------------------------- 75 Power Management 76 -------------------------------------------------------------------------- */ 77 78 /* 79 * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3. 80 * For now disable this. Probably a bug somewhere else. 81 * 82 * To skip this limit, boot/load with a large max_cstate limit. 83 */ 84 static int set_max_cstate(struct dmi_system_id *id) 85 { 86 if (max_cstate > ACPI_PROCESSOR_MAX_POWER) 87 return 0; 88 89 printk(KERN_NOTICE PREFIX "%s detected - limiting to C%ld max_cstate." 90 " Override with \"processor.max_cstate=%d\"\n", id->ident, 91 (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1); 92 93 max_cstate = (long)id->driver_data; 94 95 return 0; 96 } 97 98 /* Actually this shouldn't be __cpuinitdata, would be better to fix the 99 callers to only run once -AK */ 100 static struct dmi_system_id __cpuinitdata processor_power_dmi_table[] = { 101 { set_max_cstate, "IBM ThinkPad R40e", { 102 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 103 DMI_MATCH(DMI_BIOS_VERSION,"1SET70WW")}, (void *)1}, 104 { set_max_cstate, "IBM ThinkPad R40e", { 105 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 106 DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW")}, (void *)1}, 107 { set_max_cstate, "IBM ThinkPad R40e", { 108 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 109 DMI_MATCH(DMI_BIOS_VERSION,"1SET43WW") }, (void*)1}, 110 { set_max_cstate, "IBM ThinkPad R40e", { 111 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 112 DMI_MATCH(DMI_BIOS_VERSION,"1SET45WW") }, (void*)1}, 113 { set_max_cstate, "IBM ThinkPad R40e", { 114 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 115 DMI_MATCH(DMI_BIOS_VERSION,"1SET47WW") }, (void*)1}, 116 { set_max_cstate, "IBM ThinkPad R40e", { 117 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 118 DMI_MATCH(DMI_BIOS_VERSION,"1SET50WW") }, (void*)1}, 119 { set_max_cstate, "IBM ThinkPad R40e", { 120 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 121 DMI_MATCH(DMI_BIOS_VERSION,"1SET52WW") }, (void*)1}, 122 { set_max_cstate, "IBM ThinkPad R40e", { 123 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 124 DMI_MATCH(DMI_BIOS_VERSION,"1SET55WW") }, (void*)1}, 125 { set_max_cstate, "IBM ThinkPad R40e", { 126 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 127 DMI_MATCH(DMI_BIOS_VERSION,"1SET56WW") }, (void*)1}, 128 { set_max_cstate, "IBM ThinkPad R40e", { 129 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 130 DMI_MATCH(DMI_BIOS_VERSION,"1SET59WW") }, (void*)1}, 131 { set_max_cstate, "IBM ThinkPad R40e", { 132 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 133 DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW") }, (void*)1}, 134 { set_max_cstate, "IBM ThinkPad R40e", { 135 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 136 DMI_MATCH(DMI_BIOS_VERSION,"1SET61WW") }, (void*)1}, 137 { set_max_cstate, "IBM ThinkPad R40e", { 138 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 139 DMI_MATCH(DMI_BIOS_VERSION,"1SET62WW") }, (void*)1}, 140 { set_max_cstate, "IBM ThinkPad R40e", { 141 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 142 DMI_MATCH(DMI_BIOS_VERSION,"1SET64WW") }, (void*)1}, 143 { set_max_cstate, "IBM ThinkPad R40e", { 144 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 145 DMI_MATCH(DMI_BIOS_VERSION,"1SET65WW") }, (void*)1}, 146 { set_max_cstate, "IBM ThinkPad R40e", { 147 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"), 148 DMI_MATCH(DMI_BIOS_VERSION,"1SET68WW") }, (void*)1}, 149 { set_max_cstate, "Medion 41700", { 150 DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"), 151 DMI_MATCH(DMI_BIOS_VERSION,"R01-A1J")}, (void *)1}, 152 { set_max_cstate, "Clevo 5600D", { 153 DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"), 154 DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")}, 155 (void *)2}, 156 {}, 157 }; 158 159 static inline u32 ticks_elapsed(u32 t1, u32 t2) 160 { 161 if (t2 >= t1) 162 return (t2 - t1); 163 else if (!acpi_fadt.tmr_val_ext) 164 return (((0x00FFFFFF - t1) + t2) & 0x00FFFFFF); 165 else 166 return ((0xFFFFFFFF - t1) + t2); 167 } 168 169 static void 170 acpi_processor_power_activate(struct acpi_processor *pr, 171 struct acpi_processor_cx *new) 172 { 173 struct acpi_processor_cx *old; 174 175 if (!pr || !new) 176 return; 177 178 old = pr->power.state; 179 180 if (old) 181 old->promotion.count = 0; 182 new->demotion.count = 0; 183 184 /* Cleanup from old state. */ 185 if (old) { 186 switch (old->type) { 187 case ACPI_STATE_C3: 188 /* Disable bus master reload */ 189 if (new->type != ACPI_STATE_C3 && pr->flags.bm_check) 190 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 0, 191 ACPI_MTX_DO_NOT_LOCK); 192 break; 193 } 194 } 195 196 /* Prepare to use new state. */ 197 switch (new->type) { 198 case ACPI_STATE_C3: 199 /* Enable bus master reload */ 200 if (old->type != ACPI_STATE_C3 && pr->flags.bm_check) 201 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 1, 202 ACPI_MTX_DO_NOT_LOCK); 203 break; 204 } 205 206 pr->power.state = new; 207 208 return; 209 } 210 211 static void acpi_safe_halt(void) 212 { 213 current_thread_info()->status &= ~TS_POLLING; 214 smp_mb__after_clear_bit(); 215 if (!need_resched()) 216 safe_halt(); 217 current_thread_info()->status |= TS_POLLING; 218 } 219 220 static atomic_t c3_cpu_count; 221 222 /* Common C-state entry for C2, C3, .. */ 223 static void acpi_cstate_enter(struct acpi_processor_cx *cstate) 224 { 225 if (cstate->space_id == ACPI_CSTATE_FFH) { 226 /* Call into architectural FFH based C-state */ 227 acpi_processor_ffh_cstate_enter(cstate); 228 } else { 229 int unused; 230 /* IO port based C-state */ 231 inb(cstate->address); 232 /* Dummy wait op - must do something useless after P_LVL2 read 233 because chipsets cannot guarantee that STPCLK# signal 234 gets asserted in time to freeze execution properly. */ 235 unused = inl(acpi_fadt.xpm_tmr_blk.address); 236 } 237 } 238 239 static void acpi_processor_idle(void) 240 { 241 struct acpi_processor *pr = NULL; 242 struct acpi_processor_cx *cx = NULL; 243 struct acpi_processor_cx *next_state = NULL; 244 int sleep_ticks = 0; 245 u32 t1, t2 = 0; 246 247 pr = processors[smp_processor_id()]; 248 if (!pr) 249 return; 250 251 /* 252 * Interrupts must be disabled during bus mastering calculations and 253 * for C2/C3 transitions. 254 */ 255 local_irq_disable(); 256 257 /* 258 * Check whether we truly need to go idle, or should 259 * reschedule: 260 */ 261 if (unlikely(need_resched())) { 262 local_irq_enable(); 263 return; 264 } 265 266 cx = pr->power.state; 267 if (!cx) { 268 if (pm_idle_save) 269 pm_idle_save(); 270 else 271 acpi_safe_halt(); 272 return; 273 } 274 275 /* 276 * Check BM Activity 277 * ----------------- 278 * Check for bus mastering activity (if required), record, and check 279 * for demotion. 280 */ 281 if (pr->flags.bm_check) { 282 u32 bm_status = 0; 283 unsigned long diff = jiffies - pr->power.bm_check_timestamp; 284 285 if (diff > 31) 286 diff = 31; 287 288 pr->power.bm_activity <<= diff; 289 290 acpi_get_register(ACPI_BITREG_BUS_MASTER_STATUS, 291 &bm_status, ACPI_MTX_DO_NOT_LOCK); 292 if (bm_status) { 293 pr->power.bm_activity |= 0x1; 294 acpi_set_register(ACPI_BITREG_BUS_MASTER_STATUS, 295 1, ACPI_MTX_DO_NOT_LOCK); 296 } 297 /* 298 * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect 299 * the true state of bus mastering activity; forcing us to 300 * manually check the BMIDEA bit of each IDE channel. 301 */ 302 else if (errata.piix4.bmisx) { 303 if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01) 304 || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01)) 305 pr->power.bm_activity |= 0x1; 306 } 307 308 pr->power.bm_check_timestamp = jiffies; 309 310 /* 311 * If bus mastering is or was active this jiffy, demote 312 * to avoid a faulty transition. Note that the processor 313 * won't enter a low-power state during this call (to this 314 * function) but should upon the next. 315 * 316 * TBD: A better policy might be to fallback to the demotion 317 * state (use it for this quantum only) istead of 318 * demoting -- and rely on duration as our sole demotion 319 * qualification. This may, however, introduce DMA 320 * issues (e.g. floppy DMA transfer overrun/underrun). 321 */ 322 if ((pr->power.bm_activity & 0x1) && 323 cx->demotion.threshold.bm) { 324 local_irq_enable(); 325 next_state = cx->demotion.state; 326 goto end; 327 } 328 } 329 330 #ifdef CONFIG_HOTPLUG_CPU 331 /* 332 * Check for P_LVL2_UP flag before entering C2 and above on 333 * an SMP system. We do it here instead of doing it at _CST/P_LVL 334 * detection phase, to work cleanly with logical CPU hotplug. 335 */ 336 if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) && 337 !pr->flags.has_cst && !acpi_fadt.plvl2_up) 338 cx = &pr->power.states[ACPI_STATE_C1]; 339 #endif 340 341 /* 342 * Sleep: 343 * ------ 344 * Invoke the current Cx state to put the processor to sleep. 345 */ 346 if (cx->type == ACPI_STATE_C2 || cx->type == ACPI_STATE_C3) { 347 current_thread_info()->status &= ~TS_POLLING; 348 smp_mb__after_clear_bit(); 349 if (need_resched()) { 350 current_thread_info()->status |= TS_POLLING; 351 local_irq_enable(); 352 return; 353 } 354 } 355 356 switch (cx->type) { 357 358 case ACPI_STATE_C1: 359 /* 360 * Invoke C1. 361 * Use the appropriate idle routine, the one that would 362 * be used without acpi C-states. 363 */ 364 if (pm_idle_save) 365 pm_idle_save(); 366 else 367 acpi_safe_halt(); 368 369 /* 370 * TBD: Can't get time duration while in C1, as resumes 371 * go to an ISR rather than here. Need to instrument 372 * base interrupt handler. 373 */ 374 sleep_ticks = 0xFFFFFFFF; 375 break; 376 377 case ACPI_STATE_C2: 378 /* Get start time (ticks) */ 379 t1 = inl(acpi_fadt.xpm_tmr_blk.address); 380 /* Invoke C2 */ 381 acpi_cstate_enter(cx); 382 /* Get end time (ticks) */ 383 t2 = inl(acpi_fadt.xpm_tmr_blk.address); 384 385 #ifdef CONFIG_GENERIC_TIME 386 /* TSC halts in C2, so notify users */ 387 mark_tsc_unstable(); 388 #endif 389 /* Re-enable interrupts */ 390 local_irq_enable(); 391 current_thread_info()->status |= TS_POLLING; 392 /* Compute time (ticks) that we were actually asleep */ 393 sleep_ticks = 394 ticks_elapsed(t1, t2) - cx->latency_ticks - C2_OVERHEAD; 395 break; 396 397 case ACPI_STATE_C3: 398 399 if (pr->flags.bm_check) { 400 if (atomic_inc_return(&c3_cpu_count) == 401 num_online_cpus()) { 402 /* 403 * All CPUs are trying to go to C3 404 * Disable bus master arbitration 405 */ 406 acpi_set_register(ACPI_BITREG_ARB_DISABLE, 1, 407 ACPI_MTX_DO_NOT_LOCK); 408 } 409 } else { 410 /* SMP with no shared cache... Invalidate cache */ 411 ACPI_FLUSH_CPU_CACHE(); 412 } 413 414 /* Get start time (ticks) */ 415 t1 = inl(acpi_fadt.xpm_tmr_blk.address); 416 /* Invoke C3 */ 417 acpi_cstate_enter(cx); 418 /* Get end time (ticks) */ 419 t2 = inl(acpi_fadt.xpm_tmr_blk.address); 420 if (pr->flags.bm_check) { 421 /* Enable bus master arbitration */ 422 atomic_dec(&c3_cpu_count); 423 acpi_set_register(ACPI_BITREG_ARB_DISABLE, 0, 424 ACPI_MTX_DO_NOT_LOCK); 425 } 426 427 #ifdef CONFIG_GENERIC_TIME 428 /* TSC halts in C3, so notify users */ 429 mark_tsc_unstable(); 430 #endif 431 /* Re-enable interrupts */ 432 local_irq_enable(); 433 current_thread_info()->status |= TS_POLLING; 434 /* Compute time (ticks) that we were actually asleep */ 435 sleep_ticks = 436 ticks_elapsed(t1, t2) - cx->latency_ticks - C3_OVERHEAD; 437 break; 438 439 default: 440 local_irq_enable(); 441 return; 442 } 443 cx->usage++; 444 if ((cx->type != ACPI_STATE_C1) && (sleep_ticks > 0)) 445 cx->time += sleep_ticks; 446 447 next_state = pr->power.state; 448 449 #ifdef CONFIG_HOTPLUG_CPU 450 /* Don't do promotion/demotion */ 451 if ((cx->type == ACPI_STATE_C1) && (num_online_cpus() > 1) && 452 !pr->flags.has_cst && !acpi_fadt.plvl2_up) { 453 next_state = cx; 454 goto end; 455 } 456 #endif 457 458 /* 459 * Promotion? 460 * ---------- 461 * Track the number of longs (time asleep is greater than threshold) 462 * and promote when the count threshold is reached. Note that bus 463 * mastering activity may prevent promotions. 464 * Do not promote above max_cstate. 465 */ 466 if (cx->promotion.state && 467 ((cx->promotion.state - pr->power.states) <= max_cstate)) { 468 if (sleep_ticks > cx->promotion.threshold.ticks && 469 cx->promotion.state->latency <= system_latency_constraint()) { 470 cx->promotion.count++; 471 cx->demotion.count = 0; 472 if (cx->promotion.count >= 473 cx->promotion.threshold.count) { 474 if (pr->flags.bm_check) { 475 if (! 476 (pr->power.bm_activity & cx-> 477 promotion.threshold.bm)) { 478 next_state = 479 cx->promotion.state; 480 goto end; 481 } 482 } else { 483 next_state = cx->promotion.state; 484 goto end; 485 } 486 } 487 } 488 } 489 490 /* 491 * Demotion? 492 * --------- 493 * Track the number of shorts (time asleep is less than time threshold) 494 * and demote when the usage threshold is reached. 495 */ 496 if (cx->demotion.state) { 497 if (sleep_ticks < cx->demotion.threshold.ticks) { 498 cx->demotion.count++; 499 cx->promotion.count = 0; 500 if (cx->demotion.count >= cx->demotion.threshold.count) { 501 next_state = cx->demotion.state; 502 goto end; 503 } 504 } 505 } 506 507 end: 508 /* 509 * Demote if current state exceeds max_cstate 510 * or if the latency of the current state is unacceptable 511 */ 512 if ((pr->power.state - pr->power.states) > max_cstate || 513 pr->power.state->latency > system_latency_constraint()) { 514 if (cx->demotion.state) 515 next_state = cx->demotion.state; 516 } 517 518 /* 519 * New Cx State? 520 * ------------- 521 * If we're going to start using a new Cx state we must clean up 522 * from the previous and prepare to use the new. 523 */ 524 if (next_state != pr->power.state) 525 acpi_processor_power_activate(pr, next_state); 526 } 527 528 static int acpi_processor_set_power_policy(struct acpi_processor *pr) 529 { 530 unsigned int i; 531 unsigned int state_is_set = 0; 532 struct acpi_processor_cx *lower = NULL; 533 struct acpi_processor_cx *higher = NULL; 534 struct acpi_processor_cx *cx; 535 536 537 if (!pr) 538 return -EINVAL; 539 540 /* 541 * This function sets the default Cx state policy (OS idle handler). 542 * Our scheme is to promote quickly to C2 but more conservatively 543 * to C3. We're favoring C2 for its characteristics of low latency 544 * (quick response), good power savings, and ability to allow bus 545 * mastering activity. Note that the Cx state policy is completely 546 * customizable and can be altered dynamically. 547 */ 548 549 /* startup state */ 550 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) { 551 cx = &pr->power.states[i]; 552 if (!cx->valid) 553 continue; 554 555 if (!state_is_set) 556 pr->power.state = cx; 557 state_is_set++; 558 break; 559 } 560 561 if (!state_is_set) 562 return -ENODEV; 563 564 /* demotion */ 565 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) { 566 cx = &pr->power.states[i]; 567 if (!cx->valid) 568 continue; 569 570 if (lower) { 571 cx->demotion.state = lower; 572 cx->demotion.threshold.ticks = cx->latency_ticks; 573 cx->demotion.threshold.count = 1; 574 if (cx->type == ACPI_STATE_C3) 575 cx->demotion.threshold.bm = bm_history; 576 } 577 578 lower = cx; 579 } 580 581 /* promotion */ 582 for (i = (ACPI_PROCESSOR_MAX_POWER - 1); i > 0; i--) { 583 cx = &pr->power.states[i]; 584 if (!cx->valid) 585 continue; 586 587 if (higher) { 588 cx->promotion.state = higher; 589 cx->promotion.threshold.ticks = cx->latency_ticks; 590 if (cx->type >= ACPI_STATE_C2) 591 cx->promotion.threshold.count = 4; 592 else 593 cx->promotion.threshold.count = 10; 594 if (higher->type == ACPI_STATE_C3) 595 cx->promotion.threshold.bm = bm_history; 596 } 597 598 higher = cx; 599 } 600 601 return 0; 602 } 603 604 static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr) 605 { 606 607 if (!pr) 608 return -EINVAL; 609 610 if (!pr->pblk) 611 return -ENODEV; 612 613 /* if info is obtained from pblk/fadt, type equals state */ 614 pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2; 615 pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3; 616 617 #ifndef CONFIG_HOTPLUG_CPU 618 /* 619 * Check for P_LVL2_UP flag before entering C2 and above on 620 * an SMP system. 621 */ 622 if ((num_online_cpus() > 1) && !acpi_fadt.plvl2_up) 623 return -ENODEV; 624 #endif 625 626 /* determine C2 and C3 address from pblk */ 627 pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4; 628 pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5; 629 630 /* determine latencies from FADT */ 631 pr->power.states[ACPI_STATE_C2].latency = acpi_fadt.plvl2_lat; 632 pr->power.states[ACPI_STATE_C3].latency = acpi_fadt.plvl3_lat; 633 634 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 635 "lvl2[0x%08x] lvl3[0x%08x]\n", 636 pr->power.states[ACPI_STATE_C2].address, 637 pr->power.states[ACPI_STATE_C3].address)); 638 639 return 0; 640 } 641 642 static int acpi_processor_get_power_info_default(struct acpi_processor *pr) 643 { 644 if (!pr->power.states[ACPI_STATE_C1].valid) { 645 /* set the first C-State to C1 */ 646 /* all processors need to support C1 */ 647 pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1; 648 pr->power.states[ACPI_STATE_C1].valid = 1; 649 } 650 /* the C0 state only exists as a filler in our array */ 651 pr->power.states[ACPI_STATE_C0].valid = 1; 652 return 0; 653 } 654 655 static int acpi_processor_get_power_info_cst(struct acpi_processor *pr) 656 { 657 acpi_status status = 0; 658 acpi_integer count; 659 int current_count; 660 int i; 661 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 662 union acpi_object *cst; 663 664 665 if (nocst) 666 return -ENODEV; 667 668 current_count = 0; 669 670 status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer); 671 if (ACPI_FAILURE(status)) { 672 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _CST, giving up\n")); 673 return -ENODEV; 674 } 675 676 cst = (union acpi_object *)buffer.pointer; 677 678 /* There must be at least 2 elements */ 679 if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) { 680 printk(KERN_ERR PREFIX "not enough elements in _CST\n"); 681 status = -EFAULT; 682 goto end; 683 } 684 685 count = cst->package.elements[0].integer.value; 686 687 /* Validate number of power states. */ 688 if (count < 1 || count != cst->package.count - 1) { 689 printk(KERN_ERR PREFIX "count given by _CST is not valid\n"); 690 status = -EFAULT; 691 goto end; 692 } 693 694 /* Tell driver that at least _CST is supported. */ 695 pr->flags.has_cst = 1; 696 697 for (i = 1; i <= count; i++) { 698 union acpi_object *element; 699 union acpi_object *obj; 700 struct acpi_power_register *reg; 701 struct acpi_processor_cx cx; 702 703 memset(&cx, 0, sizeof(cx)); 704 705 element = (union acpi_object *)&(cst->package.elements[i]); 706 if (element->type != ACPI_TYPE_PACKAGE) 707 continue; 708 709 if (element->package.count != 4) 710 continue; 711 712 obj = (union acpi_object *)&(element->package.elements[0]); 713 714 if (obj->type != ACPI_TYPE_BUFFER) 715 continue; 716 717 reg = (struct acpi_power_register *)obj->buffer.pointer; 718 719 if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO && 720 (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE)) 721 continue; 722 723 /* There should be an easy way to extract an integer... */ 724 obj = (union acpi_object *)&(element->package.elements[1]); 725 if (obj->type != ACPI_TYPE_INTEGER) 726 continue; 727 728 cx.type = obj->integer.value; 729 /* 730 * Some buggy BIOSes won't list C1 in _CST - 731 * Let acpi_processor_get_power_info_default() handle them later 732 */ 733 if (i == 1 && cx.type != ACPI_STATE_C1) 734 current_count++; 735 736 cx.address = reg->address; 737 cx.index = current_count + 1; 738 739 cx.space_id = ACPI_CSTATE_SYSTEMIO; 740 if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) { 741 if (acpi_processor_ffh_cstate_probe 742 (pr->id, &cx, reg) == 0) { 743 cx.space_id = ACPI_CSTATE_FFH; 744 } else if (cx.type != ACPI_STATE_C1) { 745 /* 746 * C1 is a special case where FIXED_HARDWARE 747 * can be handled in non-MWAIT way as well. 748 * In that case, save this _CST entry info. 749 * That is, we retain space_id of SYSTEM_IO for 750 * halt based C1. 751 * Otherwise, ignore this info and continue. 752 */ 753 continue; 754 } 755 } 756 757 obj = (union acpi_object *)&(element->package.elements[2]); 758 if (obj->type != ACPI_TYPE_INTEGER) 759 continue; 760 761 cx.latency = obj->integer.value; 762 763 obj = (union acpi_object *)&(element->package.elements[3]); 764 if (obj->type != ACPI_TYPE_INTEGER) 765 continue; 766 767 cx.power = obj->integer.value; 768 769 current_count++; 770 memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx)); 771 772 /* 773 * We support total ACPI_PROCESSOR_MAX_POWER - 1 774 * (From 1 through ACPI_PROCESSOR_MAX_POWER - 1) 775 */ 776 if (current_count >= (ACPI_PROCESSOR_MAX_POWER - 1)) { 777 printk(KERN_WARNING 778 "Limiting number of power states to max (%d)\n", 779 ACPI_PROCESSOR_MAX_POWER); 780 printk(KERN_WARNING 781 "Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n"); 782 break; 783 } 784 } 785 786 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n", 787 current_count)); 788 789 /* Validate number of power states discovered */ 790 if (current_count < 2) 791 status = -EFAULT; 792 793 end: 794 kfree(buffer.pointer); 795 796 return status; 797 } 798 799 static void acpi_processor_power_verify_c2(struct acpi_processor_cx *cx) 800 { 801 802 if (!cx->address) 803 return; 804 805 /* 806 * C2 latency must be less than or equal to 100 807 * microseconds. 808 */ 809 else if (cx->latency > ACPI_PROCESSOR_MAX_C2_LATENCY) { 810 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 811 "latency too large [%d]\n", cx->latency)); 812 return; 813 } 814 815 /* 816 * Otherwise we've met all of our C2 requirements. 817 * Normalize the C2 latency to expidite policy 818 */ 819 cx->valid = 1; 820 cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency); 821 822 return; 823 } 824 825 static void acpi_processor_power_verify_c3(struct acpi_processor *pr, 826 struct acpi_processor_cx *cx) 827 { 828 static int bm_check_flag; 829 830 831 if (!cx->address) 832 return; 833 834 /* 835 * C3 latency must be less than or equal to 1000 836 * microseconds. 837 */ 838 else if (cx->latency > ACPI_PROCESSOR_MAX_C3_LATENCY) { 839 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 840 "latency too large [%d]\n", cx->latency)); 841 return; 842 } 843 844 /* 845 * PIIX4 Erratum #18: We don't support C3 when Type-F (fast) 846 * DMA transfers are used by any ISA device to avoid livelock. 847 * Note that we could disable Type-F DMA (as recommended by 848 * the erratum), but this is known to disrupt certain ISA 849 * devices thus we take the conservative approach. 850 */ 851 else if (errata.piix4.fdma) { 852 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 853 "C3 not supported on PIIX4 with Type-F DMA\n")); 854 return; 855 } 856 857 /* All the logic here assumes flags.bm_check is same across all CPUs */ 858 if (!bm_check_flag) { 859 /* Determine whether bm_check is needed based on CPU */ 860 acpi_processor_power_init_bm_check(&(pr->flags), pr->id); 861 bm_check_flag = pr->flags.bm_check; 862 } else { 863 pr->flags.bm_check = bm_check_flag; 864 } 865 866 if (pr->flags.bm_check) { 867 /* bus mastering control is necessary */ 868 if (!pr->flags.bm_control) { 869 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 870 "C3 support requires bus mastering control\n")); 871 return; 872 } 873 } else { 874 /* 875 * WBINVD should be set in fadt, for C3 state to be 876 * supported on when bm_check is not required. 877 */ 878 if (acpi_fadt.wb_invd != 1) { 879 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 880 "Cache invalidation should work properly" 881 " for C3 to be enabled on SMP systems\n")); 882 return; 883 } 884 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 885 0, ACPI_MTX_DO_NOT_LOCK); 886 } 887 888 /* 889 * Otherwise we've met all of our C3 requirements. 890 * Normalize the C3 latency to expidite policy. Enable 891 * checking of bus mastering status (bm_check) so we can 892 * use this in our C3 policy 893 */ 894 cx->valid = 1; 895 cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency); 896 897 return; 898 } 899 900 static int acpi_processor_power_verify(struct acpi_processor *pr) 901 { 902 unsigned int i; 903 unsigned int working = 0; 904 905 #ifdef ARCH_APICTIMER_STOPS_ON_C3 906 int timer_broadcast = 0; 907 cpumask_t mask = cpumask_of_cpu(pr->id); 908 on_each_cpu(switch_ipi_to_APIC_timer, &mask, 1, 1); 909 #endif 910 911 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) { 912 struct acpi_processor_cx *cx = &pr->power.states[i]; 913 914 switch (cx->type) { 915 case ACPI_STATE_C1: 916 cx->valid = 1; 917 break; 918 919 case ACPI_STATE_C2: 920 acpi_processor_power_verify_c2(cx); 921 #ifdef ARCH_APICTIMER_STOPS_ON_C3 922 /* Some AMD systems fake C3 as C2, but still 923 have timer troubles */ 924 if (cx->valid && 925 boot_cpu_data.x86_vendor == X86_VENDOR_AMD) 926 timer_broadcast++; 927 #endif 928 break; 929 930 case ACPI_STATE_C3: 931 acpi_processor_power_verify_c3(pr, cx); 932 #ifdef ARCH_APICTIMER_STOPS_ON_C3 933 if (cx->valid) 934 timer_broadcast++; 935 #endif 936 break; 937 } 938 939 if (cx->valid) 940 working++; 941 } 942 943 #ifdef ARCH_APICTIMER_STOPS_ON_C3 944 if (timer_broadcast) 945 on_each_cpu(switch_APIC_timer_to_ipi, &mask, 1, 1); 946 #endif 947 948 return (working); 949 } 950 951 static int acpi_processor_get_power_info(struct acpi_processor *pr) 952 { 953 unsigned int i; 954 int result; 955 956 957 /* NOTE: the idle thread may not be running while calling 958 * this function */ 959 960 /* Zero initialize all the C-states info. */ 961 memset(pr->power.states, 0, sizeof(pr->power.states)); 962 963 result = acpi_processor_get_power_info_cst(pr); 964 if (result == -ENODEV) 965 result = acpi_processor_get_power_info_fadt(pr); 966 967 if (result) 968 return result; 969 970 acpi_processor_get_power_info_default(pr); 971 972 pr->power.count = acpi_processor_power_verify(pr); 973 974 /* 975 * Set Default Policy 976 * ------------------ 977 * Now that we know which states are supported, set the default 978 * policy. Note that this policy can be changed dynamically 979 * (e.g. encourage deeper sleeps to conserve battery life when 980 * not on AC). 981 */ 982 result = acpi_processor_set_power_policy(pr); 983 if (result) 984 return result; 985 986 /* 987 * if one state of type C2 or C3 is available, mark this 988 * CPU as being "idle manageable" 989 */ 990 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) { 991 if (pr->power.states[i].valid) { 992 pr->power.count = i; 993 if (pr->power.states[i].type >= ACPI_STATE_C2) 994 pr->flags.power = 1; 995 } 996 } 997 998 return 0; 999 } 1000 1001 int acpi_processor_cst_has_changed(struct acpi_processor *pr) 1002 { 1003 int result = 0; 1004 1005 1006 if (!pr) 1007 return -EINVAL; 1008 1009 if (nocst) { 1010 return -ENODEV; 1011 } 1012 1013 if (!pr->flags.power_setup_done) 1014 return -ENODEV; 1015 1016 /* Fall back to the default idle loop */ 1017 pm_idle = pm_idle_save; 1018 synchronize_sched(); /* Relies on interrupts forcing exit from idle. */ 1019 1020 pr->flags.power = 0; 1021 result = acpi_processor_get_power_info(pr); 1022 if ((pr->flags.power == 1) && (pr->flags.power_setup_done)) 1023 pm_idle = acpi_processor_idle; 1024 1025 return result; 1026 } 1027 1028 /* proc interface */ 1029 1030 static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset) 1031 { 1032 struct acpi_processor *pr = (struct acpi_processor *)seq->private; 1033 unsigned int i; 1034 1035 1036 if (!pr) 1037 goto end; 1038 1039 seq_printf(seq, "active state: C%zd\n" 1040 "max_cstate: C%d\n" 1041 "bus master activity: %08x\n" 1042 "maximum allowed latency: %d usec\n", 1043 pr->power.state ? pr->power.state - pr->power.states : 0, 1044 max_cstate, (unsigned)pr->power.bm_activity, 1045 system_latency_constraint()); 1046 1047 seq_puts(seq, "states:\n"); 1048 1049 for (i = 1; i <= pr->power.count; i++) { 1050 seq_printf(seq, " %cC%d: ", 1051 (&pr->power.states[i] == 1052 pr->power.state ? '*' : ' '), i); 1053 1054 if (!pr->power.states[i].valid) { 1055 seq_puts(seq, "<not supported>\n"); 1056 continue; 1057 } 1058 1059 switch (pr->power.states[i].type) { 1060 case ACPI_STATE_C1: 1061 seq_printf(seq, "type[C1] "); 1062 break; 1063 case ACPI_STATE_C2: 1064 seq_printf(seq, "type[C2] "); 1065 break; 1066 case ACPI_STATE_C3: 1067 seq_printf(seq, "type[C3] "); 1068 break; 1069 default: 1070 seq_printf(seq, "type[--] "); 1071 break; 1072 } 1073 1074 if (pr->power.states[i].promotion.state) 1075 seq_printf(seq, "promotion[C%zd] ", 1076 (pr->power.states[i].promotion.state - 1077 pr->power.states)); 1078 else 1079 seq_puts(seq, "promotion[--] "); 1080 1081 if (pr->power.states[i].demotion.state) 1082 seq_printf(seq, "demotion[C%zd] ", 1083 (pr->power.states[i].demotion.state - 1084 pr->power.states)); 1085 else 1086 seq_puts(seq, "demotion[--] "); 1087 1088 seq_printf(seq, "latency[%03d] usage[%08d] duration[%020llu]\n", 1089 pr->power.states[i].latency, 1090 pr->power.states[i].usage, 1091 pr->power.states[i].time); 1092 } 1093 1094 end: 1095 return 0; 1096 } 1097 1098 static int acpi_processor_power_open_fs(struct inode *inode, struct file *file) 1099 { 1100 return single_open(file, acpi_processor_power_seq_show, 1101 PDE(inode)->data); 1102 } 1103 1104 static const struct file_operations acpi_processor_power_fops = { 1105 .open = acpi_processor_power_open_fs, 1106 .read = seq_read, 1107 .llseek = seq_lseek, 1108 .release = single_release, 1109 }; 1110 1111 #ifdef CONFIG_SMP 1112 static void smp_callback(void *v) 1113 { 1114 /* we already woke the CPU up, nothing more to do */ 1115 } 1116 1117 /* 1118 * This function gets called when a part of the kernel has a new latency 1119 * requirement. This means we need to get all processors out of their C-state, 1120 * and then recalculate a new suitable C-state. Just do a cross-cpu IPI; that 1121 * wakes them all right up. 1122 */ 1123 static int acpi_processor_latency_notify(struct notifier_block *b, 1124 unsigned long l, void *v) 1125 { 1126 smp_call_function(smp_callback, NULL, 0, 1); 1127 return NOTIFY_OK; 1128 } 1129 1130 static struct notifier_block acpi_processor_latency_notifier = { 1131 .notifier_call = acpi_processor_latency_notify, 1132 }; 1133 #endif 1134 1135 int __cpuinit acpi_processor_power_init(struct acpi_processor *pr, 1136 struct acpi_device *device) 1137 { 1138 acpi_status status = 0; 1139 static int first_run; 1140 struct proc_dir_entry *entry = NULL; 1141 unsigned int i; 1142 1143 1144 if (!first_run) { 1145 dmi_check_system(processor_power_dmi_table); 1146 if (max_cstate < ACPI_C_STATES_MAX) 1147 printk(KERN_NOTICE 1148 "ACPI: processor limited to max C-state %d\n", 1149 max_cstate); 1150 first_run++; 1151 #ifdef CONFIG_SMP 1152 register_latency_notifier(&acpi_processor_latency_notifier); 1153 #endif 1154 } 1155 1156 if (!pr) 1157 return -EINVAL; 1158 1159 if (acpi_fadt.cst_cnt && !nocst) { 1160 status = 1161 acpi_os_write_port(acpi_fadt.smi_cmd, acpi_fadt.cst_cnt, 8); 1162 if (ACPI_FAILURE(status)) { 1163 ACPI_EXCEPTION((AE_INFO, status, 1164 "Notifying BIOS of _CST ability failed")); 1165 } 1166 } 1167 1168 acpi_processor_get_power_info(pr); 1169 1170 /* 1171 * Install the idle handler if processor power management is supported. 1172 * Note that we use previously set idle handler will be used on 1173 * platforms that only support C1. 1174 */ 1175 if ((pr->flags.power) && (!boot_option_idle_override)) { 1176 printk(KERN_INFO PREFIX "CPU%d (power states:", pr->id); 1177 for (i = 1; i <= pr->power.count; i++) 1178 if (pr->power.states[i].valid) 1179 printk(" C%d[C%d]", i, 1180 pr->power.states[i].type); 1181 printk(")\n"); 1182 1183 if (pr->id == 0) { 1184 pm_idle_save = pm_idle; 1185 pm_idle = acpi_processor_idle; 1186 } 1187 } 1188 1189 /* 'power' [R] */ 1190 entry = create_proc_entry(ACPI_PROCESSOR_FILE_POWER, 1191 S_IRUGO, acpi_device_dir(device)); 1192 if (!entry) 1193 return -EIO; 1194 else { 1195 entry->proc_fops = &acpi_processor_power_fops; 1196 entry->data = acpi_driver_data(device); 1197 entry->owner = THIS_MODULE; 1198 } 1199 1200 pr->flags.power_setup_done = 1; 1201 1202 return 0; 1203 } 1204 1205 int acpi_processor_power_exit(struct acpi_processor *pr, 1206 struct acpi_device *device) 1207 { 1208 1209 pr->flags.power_setup_done = 0; 1210 1211 if (acpi_device_dir(device)) 1212 remove_proc_entry(ACPI_PROCESSOR_FILE_POWER, 1213 acpi_device_dir(device)); 1214 1215 /* Unregister the idle handler when processor #0 is removed. */ 1216 if (pr->id == 0) { 1217 pm_idle = pm_idle_save; 1218 1219 /* 1220 * We are about to unload the current idle thread pm callback 1221 * (pm_idle), Wait for all processors to update cached/local 1222 * copies of pm_idle before proceeding. 1223 */ 1224 cpu_idle_wait(); 1225 #ifdef CONFIG_SMP 1226 unregister_latency_notifier(&acpi_processor_latency_notifier); 1227 #endif 1228 } 1229 1230 return 0; 1231 } 1232