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 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 41 #include <asm/io.h> 42 #include <asm/uaccess.h> 43 44 #include <acpi/acpi_bus.h> 45 #include <acpi/processor.h> 46 47 #define ACPI_PROCESSOR_COMPONENT 0x01000000 48 #define ACPI_PROCESSOR_CLASS "processor" 49 #define ACPI_PROCESSOR_DRIVER_NAME "ACPI Processor Driver" 50 #define _COMPONENT ACPI_PROCESSOR_COMPONENT 51 ACPI_MODULE_NAME("acpi_processor") 52 #define ACPI_PROCESSOR_FILE_POWER "power" 53 #define US_TO_PM_TIMER_TICKS(t) ((t * (PM_TIMER_FREQUENCY/1000)) / 1000) 54 #define C2_OVERHEAD 4 /* 1us (3.579 ticks per us) */ 55 #define C3_OVERHEAD 4 /* 1us (3.579 ticks per us) */ 56 static void (*pm_idle_save) (void); 57 module_param(max_cstate, uint, 0644); 58 59 static unsigned int nocst = 0; 60 module_param(nocst, uint, 0000); 61 62 /* 63 * bm_history -- bit-mask with a bit per jiffy of bus-master activity 64 * 1000 HZ: 0xFFFFFFFF: 32 jiffies = 32ms 65 * 800 HZ: 0xFFFFFFFF: 32 jiffies = 40ms 66 * 100 HZ: 0x0000000F: 4 jiffies = 40ms 67 * reduce history for more aggressive entry into C3 68 */ 69 static unsigned int bm_history = 70 (HZ >= 800 ? 0xFFFFFFFF : ((1U << (HZ / 25)) - 1)); 71 module_param(bm_history, uint, 0644); 72 /* -------------------------------------------------------------------------- 73 Power Management 74 -------------------------------------------------------------------------- */ 75 76 /* 77 * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3. 78 * For now disable this. Probably a bug somewhere else. 79 * 80 * To skip this limit, boot/load with a large max_cstate limit. 81 */ 82 static int set_max_cstate(struct dmi_system_id *id) 83 { 84 if (max_cstate > ACPI_PROCESSOR_MAX_POWER) 85 return 0; 86 87 printk(KERN_NOTICE PREFIX "%s detected - limiting to C%ld max_cstate." 88 " Override with \"processor.max_cstate=%d\"\n", id->ident, 89 (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1); 90 91 max_cstate = (long)id->driver_data; 92 93 return 0; 94 } 95 96 static struct dmi_system_id __initdata processor_power_dmi_table[] = { 97 {set_max_cstate, "IBM ThinkPad R40e", { 98 DMI_MATCH(DMI_BIOS_VENDOR, 99 "IBM"), 100 DMI_MATCH(DMI_BIOS_VERSION, 101 "1SET60WW")}, 102 (void *)1}, 103 {set_max_cstate, "Medion 41700", { 104 DMI_MATCH(DMI_BIOS_VENDOR, 105 "Phoenix Technologies LTD"), 106 DMI_MATCH(DMI_BIOS_VERSION, 107 "R01-A1J")}, (void *)1}, 108 {set_max_cstate, "Clevo 5600D", { 109 DMI_MATCH(DMI_BIOS_VENDOR, 110 "Phoenix Technologies LTD"), 111 DMI_MATCH(DMI_BIOS_VERSION, 112 "SHE845M0.86C.0013.D.0302131307")}, 113 (void *)2}, 114 {}, 115 }; 116 117 static inline u32 ticks_elapsed(u32 t1, u32 t2) 118 { 119 if (t2 >= t1) 120 return (t2 - t1); 121 else if (!acpi_fadt.tmr_val_ext) 122 return (((0x00FFFFFF - t1) + t2) & 0x00FFFFFF); 123 else 124 return ((0xFFFFFFFF - t1) + t2); 125 } 126 127 static void 128 acpi_processor_power_activate(struct acpi_processor *pr, 129 struct acpi_processor_cx *new) 130 { 131 struct acpi_processor_cx *old; 132 133 if (!pr || !new) 134 return; 135 136 old = pr->power.state; 137 138 if (old) 139 old->promotion.count = 0; 140 new->demotion.count = 0; 141 142 /* Cleanup from old state. */ 143 if (old) { 144 switch (old->type) { 145 case ACPI_STATE_C3: 146 /* Disable bus master reload */ 147 if (new->type != ACPI_STATE_C3 && pr->flags.bm_check) 148 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 0, 149 ACPI_MTX_DO_NOT_LOCK); 150 break; 151 } 152 } 153 154 /* Prepare to use new state. */ 155 switch (new->type) { 156 case ACPI_STATE_C3: 157 /* Enable bus master reload */ 158 if (old->type != ACPI_STATE_C3 && pr->flags.bm_check) 159 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 1, 160 ACPI_MTX_DO_NOT_LOCK); 161 break; 162 } 163 164 pr->power.state = new; 165 166 return; 167 } 168 169 static atomic_t c3_cpu_count; 170 171 static void acpi_processor_idle(void) 172 { 173 struct acpi_processor *pr = NULL; 174 struct acpi_processor_cx *cx = NULL; 175 struct acpi_processor_cx *next_state = NULL; 176 int sleep_ticks = 0; 177 u32 t1, t2 = 0; 178 179 pr = processors[raw_smp_processor_id()]; 180 if (!pr) 181 return; 182 183 /* 184 * Interrupts must be disabled during bus mastering calculations and 185 * for C2/C3 transitions. 186 */ 187 local_irq_disable(); 188 189 /* 190 * Check whether we truly need to go idle, or should 191 * reschedule: 192 */ 193 if (unlikely(need_resched())) { 194 local_irq_enable(); 195 return; 196 } 197 198 cx = pr->power.state; 199 if (!cx) 200 goto easy_out; 201 202 /* 203 * Check BM Activity 204 * ----------------- 205 * Check for bus mastering activity (if required), record, and check 206 * for demotion. 207 */ 208 if (pr->flags.bm_check) { 209 u32 bm_status = 0; 210 unsigned long diff = jiffies - pr->power.bm_check_timestamp; 211 212 if (diff > 32) 213 diff = 32; 214 215 while (diff) { 216 /* if we didn't get called, assume there was busmaster activity */ 217 diff--; 218 if (diff) 219 pr->power.bm_activity |= 0x1; 220 pr->power.bm_activity <<= 1; 221 } 222 223 acpi_get_register(ACPI_BITREG_BUS_MASTER_STATUS, 224 &bm_status, ACPI_MTX_DO_NOT_LOCK); 225 if (bm_status) { 226 pr->power.bm_activity++; 227 acpi_set_register(ACPI_BITREG_BUS_MASTER_STATUS, 228 1, ACPI_MTX_DO_NOT_LOCK); 229 } 230 /* 231 * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect 232 * the true state of bus mastering activity; forcing us to 233 * manually check the BMIDEA bit of each IDE channel. 234 */ 235 else if (errata.piix4.bmisx) { 236 if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01) 237 || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01)) 238 pr->power.bm_activity++; 239 } 240 241 pr->power.bm_check_timestamp = jiffies; 242 243 /* 244 * Apply bus mastering demotion policy. Automatically demote 245 * to avoid a faulty transition. Note that the processor 246 * won't enter a low-power state during this call (to this 247 * funciton) but should upon the next. 248 * 249 * TBD: A better policy might be to fallback to the demotion 250 * state (use it for this quantum only) istead of 251 * demoting -- and rely on duration as our sole demotion 252 * qualification. This may, however, introduce DMA 253 * issues (e.g. floppy DMA transfer overrun/underrun). 254 */ 255 if (pr->power.bm_activity & cx->demotion.threshold.bm) { 256 local_irq_enable(); 257 next_state = cx->demotion.state; 258 goto end; 259 } 260 } 261 262 cx->usage++; 263 264 /* 265 * Sleep: 266 * ------ 267 * Invoke the current Cx state to put the processor to sleep. 268 */ 269 switch (cx->type) { 270 271 case ACPI_STATE_C1: 272 /* 273 * Invoke C1. 274 * Use the appropriate idle routine, the one that would 275 * be used without acpi C-states. 276 */ 277 if (pm_idle_save) 278 pm_idle_save(); 279 else 280 safe_halt(); 281 /* 282 * TBD: Can't get time duration while in C1, as resumes 283 * go to an ISR rather than here. Need to instrument 284 * base interrupt handler. 285 */ 286 sleep_ticks = 0xFFFFFFFF; 287 break; 288 289 case ACPI_STATE_C2: 290 /* Get start time (ticks) */ 291 t1 = inl(acpi_fadt.xpm_tmr_blk.address); 292 /* Invoke C2 */ 293 inb(cx->address); 294 /* Dummy op - must do something useless after P_LVL2 read */ 295 t2 = inl(acpi_fadt.xpm_tmr_blk.address); 296 /* Get end time (ticks) */ 297 t2 = inl(acpi_fadt.xpm_tmr_blk.address); 298 /* Re-enable interrupts */ 299 local_irq_enable(); 300 /* Compute time (ticks) that we were actually asleep */ 301 sleep_ticks = 302 ticks_elapsed(t1, t2) - cx->latency_ticks - C2_OVERHEAD; 303 break; 304 305 case ACPI_STATE_C3: 306 307 if (pr->flags.bm_check) { 308 if (atomic_inc_return(&c3_cpu_count) == 309 num_online_cpus()) { 310 /* 311 * All CPUs are trying to go to C3 312 * Disable bus master arbitration 313 */ 314 acpi_set_register(ACPI_BITREG_ARB_DISABLE, 1, 315 ACPI_MTX_DO_NOT_LOCK); 316 } 317 } else { 318 /* SMP with no shared cache... Invalidate cache */ 319 ACPI_FLUSH_CPU_CACHE(); 320 } 321 322 /* Get start time (ticks) */ 323 t1 = inl(acpi_fadt.xpm_tmr_blk.address); 324 /* Invoke C3 */ 325 inb(cx->address); 326 /* Dummy op - must do something useless after P_LVL3 read */ 327 t2 = inl(acpi_fadt.xpm_tmr_blk.address); 328 /* Get end time (ticks) */ 329 t2 = inl(acpi_fadt.xpm_tmr_blk.address); 330 if (pr->flags.bm_check) { 331 /* Enable bus master arbitration */ 332 atomic_dec(&c3_cpu_count); 333 acpi_set_register(ACPI_BITREG_ARB_DISABLE, 0, 334 ACPI_MTX_DO_NOT_LOCK); 335 } 336 337 /* Re-enable interrupts */ 338 local_irq_enable(); 339 /* Compute time (ticks) that we were actually asleep */ 340 sleep_ticks = 341 ticks_elapsed(t1, t2) - cx->latency_ticks - C3_OVERHEAD; 342 break; 343 344 default: 345 local_irq_enable(); 346 return; 347 } 348 349 next_state = pr->power.state; 350 351 /* 352 * Promotion? 353 * ---------- 354 * Track the number of longs (time asleep is greater than threshold) 355 * and promote when the count threshold is reached. Note that bus 356 * mastering activity may prevent promotions. 357 * Do not promote above max_cstate. 358 */ 359 if (cx->promotion.state && 360 ((cx->promotion.state - pr->power.states) <= max_cstate)) { 361 if (sleep_ticks > cx->promotion.threshold.ticks) { 362 cx->promotion.count++; 363 cx->demotion.count = 0; 364 if (cx->promotion.count >= 365 cx->promotion.threshold.count) { 366 if (pr->flags.bm_check) { 367 if (! 368 (pr->power.bm_activity & cx-> 369 promotion.threshold.bm)) { 370 next_state = 371 cx->promotion.state; 372 goto end; 373 } 374 } else { 375 next_state = cx->promotion.state; 376 goto end; 377 } 378 } 379 } 380 } 381 382 /* 383 * Demotion? 384 * --------- 385 * Track the number of shorts (time asleep is less than time threshold) 386 * and demote when the usage threshold is reached. 387 */ 388 if (cx->demotion.state) { 389 if (sleep_ticks < cx->demotion.threshold.ticks) { 390 cx->demotion.count++; 391 cx->promotion.count = 0; 392 if (cx->demotion.count >= cx->demotion.threshold.count) { 393 next_state = cx->demotion.state; 394 goto end; 395 } 396 } 397 } 398 399 end: 400 /* 401 * Demote if current state exceeds max_cstate 402 */ 403 if ((pr->power.state - pr->power.states) > max_cstate) { 404 if (cx->demotion.state) 405 next_state = cx->demotion.state; 406 } 407 408 /* 409 * New Cx State? 410 * ------------- 411 * If we're going to start using a new Cx state we must clean up 412 * from the previous and prepare to use the new. 413 */ 414 if (next_state != pr->power.state) 415 acpi_processor_power_activate(pr, next_state); 416 417 return; 418 419 easy_out: 420 /* do C1 instead of busy loop */ 421 if (pm_idle_save) 422 pm_idle_save(); 423 else 424 safe_halt(); 425 return; 426 } 427 428 static int acpi_processor_set_power_policy(struct acpi_processor *pr) 429 { 430 unsigned int i; 431 unsigned int state_is_set = 0; 432 struct acpi_processor_cx *lower = NULL; 433 struct acpi_processor_cx *higher = NULL; 434 struct acpi_processor_cx *cx; 435 436 ACPI_FUNCTION_TRACE("acpi_processor_set_power_policy"); 437 438 if (!pr) 439 return_VALUE(-EINVAL); 440 441 /* 442 * This function sets the default Cx state policy (OS idle handler). 443 * Our scheme is to promote quickly to C2 but more conservatively 444 * to C3. We're favoring C2 for its characteristics of low latency 445 * (quick response), good power savings, and ability to allow bus 446 * mastering activity. Note that the Cx state policy is completely 447 * customizable and can be altered dynamically. 448 */ 449 450 /* startup state */ 451 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) { 452 cx = &pr->power.states[i]; 453 if (!cx->valid) 454 continue; 455 456 if (!state_is_set) 457 pr->power.state = cx; 458 state_is_set++; 459 break; 460 } 461 462 if (!state_is_set) 463 return_VALUE(-ENODEV); 464 465 /* demotion */ 466 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) { 467 cx = &pr->power.states[i]; 468 if (!cx->valid) 469 continue; 470 471 if (lower) { 472 cx->demotion.state = lower; 473 cx->demotion.threshold.ticks = cx->latency_ticks; 474 cx->demotion.threshold.count = 1; 475 if (cx->type == ACPI_STATE_C3) 476 cx->demotion.threshold.bm = bm_history; 477 } 478 479 lower = cx; 480 } 481 482 /* promotion */ 483 for (i = (ACPI_PROCESSOR_MAX_POWER - 1); i > 0; i--) { 484 cx = &pr->power.states[i]; 485 if (!cx->valid) 486 continue; 487 488 if (higher) { 489 cx->promotion.state = higher; 490 cx->promotion.threshold.ticks = cx->latency_ticks; 491 if (cx->type >= ACPI_STATE_C2) 492 cx->promotion.threshold.count = 4; 493 else 494 cx->promotion.threshold.count = 10; 495 if (higher->type == ACPI_STATE_C3) 496 cx->promotion.threshold.bm = bm_history; 497 } 498 499 higher = cx; 500 } 501 502 return_VALUE(0); 503 } 504 505 static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr) 506 { 507 int i; 508 509 ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_fadt"); 510 511 if (!pr) 512 return_VALUE(-EINVAL); 513 514 if (!pr->pblk) 515 return_VALUE(-ENODEV); 516 517 for (i = 0; i < ACPI_PROCESSOR_MAX_POWER; i++) 518 memset(pr->power.states, 0, sizeof(struct acpi_processor_cx)); 519 520 /* if info is obtained from pblk/fadt, type equals state */ 521 pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1; 522 pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2; 523 pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3; 524 525 /* the C0 state only exists as a filler in our array, 526 * and all processors need to support C1 */ 527 pr->power.states[ACPI_STATE_C0].valid = 1; 528 pr->power.states[ACPI_STATE_C1].valid = 1; 529 530 /* determine C2 and C3 address from pblk */ 531 pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4; 532 pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5; 533 534 /* determine latencies from FADT */ 535 pr->power.states[ACPI_STATE_C2].latency = acpi_fadt.plvl2_lat; 536 pr->power.states[ACPI_STATE_C3].latency = acpi_fadt.plvl3_lat; 537 538 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 539 "lvl2[0x%08x] lvl3[0x%08x]\n", 540 pr->power.states[ACPI_STATE_C2].address, 541 pr->power.states[ACPI_STATE_C3].address)); 542 543 return_VALUE(0); 544 } 545 546 static int acpi_processor_get_power_info_default_c1(struct acpi_processor *pr) 547 { 548 int i; 549 550 ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_default_c1"); 551 552 for (i = 0; i < ACPI_PROCESSOR_MAX_POWER; i++) 553 memset(&(pr->power.states[i]), 0, 554 sizeof(struct acpi_processor_cx)); 555 556 /* if info is obtained from pblk/fadt, type equals state */ 557 pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1; 558 pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2; 559 pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3; 560 561 /* the C0 state only exists as a filler in our array, 562 * and all processors need to support C1 */ 563 pr->power.states[ACPI_STATE_C0].valid = 1; 564 pr->power.states[ACPI_STATE_C1].valid = 1; 565 566 return_VALUE(0); 567 } 568 569 static int acpi_processor_get_power_info_cst(struct acpi_processor *pr) 570 { 571 acpi_status status = 0; 572 acpi_integer count; 573 int i; 574 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 575 union acpi_object *cst; 576 577 ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_cst"); 578 579 if (nocst) 580 return_VALUE(-ENODEV); 581 582 pr->power.count = 0; 583 for (i = 0; i < ACPI_PROCESSOR_MAX_POWER; i++) 584 memset(&(pr->power.states[i]), 0, 585 sizeof(struct acpi_processor_cx)); 586 587 status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer); 588 if (ACPI_FAILURE(status)) { 589 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _CST, giving up\n")); 590 return_VALUE(-ENODEV); 591 } 592 593 cst = (union acpi_object *)buffer.pointer; 594 595 /* There must be at least 2 elements */ 596 if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) { 597 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 598 "not enough elements in _CST\n")); 599 status = -EFAULT; 600 goto end; 601 } 602 603 count = cst->package.elements[0].integer.value; 604 605 /* Validate number of power states. */ 606 if (count < 1 || count != cst->package.count - 1) { 607 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 608 "count given by _CST is not valid\n")); 609 status = -EFAULT; 610 goto end; 611 } 612 613 /* We support up to ACPI_PROCESSOR_MAX_POWER. */ 614 if (count > ACPI_PROCESSOR_MAX_POWER) { 615 printk(KERN_WARNING 616 "Limiting number of power states to max (%d)\n", 617 ACPI_PROCESSOR_MAX_POWER); 618 printk(KERN_WARNING 619 "Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n"); 620 count = ACPI_PROCESSOR_MAX_POWER; 621 } 622 623 /* Tell driver that at least _CST is supported. */ 624 pr->flags.has_cst = 1; 625 626 for (i = 1; i <= count; i++) { 627 union acpi_object *element; 628 union acpi_object *obj; 629 struct acpi_power_register *reg; 630 struct acpi_processor_cx cx; 631 632 memset(&cx, 0, sizeof(cx)); 633 634 element = (union acpi_object *)&(cst->package.elements[i]); 635 if (element->type != ACPI_TYPE_PACKAGE) 636 continue; 637 638 if (element->package.count != 4) 639 continue; 640 641 obj = (union acpi_object *)&(element->package.elements[0]); 642 643 if (obj->type != ACPI_TYPE_BUFFER) 644 continue; 645 646 reg = (struct acpi_power_register *)obj->buffer.pointer; 647 648 if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO && 649 (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE)) 650 continue; 651 652 cx.address = (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) ? 653 0 : reg->address; 654 655 /* There should be an easy way to extract an integer... */ 656 obj = (union acpi_object *)&(element->package.elements[1]); 657 if (obj->type != ACPI_TYPE_INTEGER) 658 continue; 659 660 cx.type = obj->integer.value; 661 662 if ((cx.type != ACPI_STATE_C1) && 663 (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO)) 664 continue; 665 666 if ((cx.type < ACPI_STATE_C1) || (cx.type > ACPI_STATE_C3)) 667 continue; 668 669 obj = (union acpi_object *)&(element->package.elements[2]); 670 if (obj->type != ACPI_TYPE_INTEGER) 671 continue; 672 673 cx.latency = obj->integer.value; 674 675 obj = (union acpi_object *)&(element->package.elements[3]); 676 if (obj->type != ACPI_TYPE_INTEGER) 677 continue; 678 679 cx.power = obj->integer.value; 680 681 (pr->power.count)++; 682 memcpy(&(pr->power.states[pr->power.count]), &cx, sizeof(cx)); 683 } 684 685 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n", 686 pr->power.count)); 687 688 /* Validate number of power states discovered */ 689 if (pr->power.count < 2) 690 status = -ENODEV; 691 692 end: 693 acpi_os_free(buffer.pointer); 694 695 return_VALUE(status); 696 } 697 698 static void acpi_processor_power_verify_c2(struct acpi_processor_cx *cx) 699 { 700 ACPI_FUNCTION_TRACE("acpi_processor_get_power_verify_c2"); 701 702 if (!cx->address) 703 return_VOID; 704 705 /* 706 * C2 latency must be less than or equal to 100 707 * microseconds. 708 */ 709 else if (cx->latency > ACPI_PROCESSOR_MAX_C2_LATENCY) { 710 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 711 "latency too large [%d]\n", cx->latency)); 712 return_VOID; 713 } 714 715 /* 716 * Otherwise we've met all of our C2 requirements. 717 * Normalize the C2 latency to expidite policy 718 */ 719 cx->valid = 1; 720 cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency); 721 722 return_VOID; 723 } 724 725 static void acpi_processor_power_verify_c3(struct acpi_processor *pr, 726 struct acpi_processor_cx *cx) 727 { 728 static int bm_check_flag; 729 730 ACPI_FUNCTION_TRACE("acpi_processor_get_power_verify_c3"); 731 732 if (!cx->address) 733 return_VOID; 734 735 /* 736 * C3 latency must be less than or equal to 1000 737 * microseconds. 738 */ 739 else if (cx->latency > ACPI_PROCESSOR_MAX_C3_LATENCY) { 740 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 741 "latency too large [%d]\n", cx->latency)); 742 return_VOID; 743 } 744 745 /* 746 * PIIX4 Erratum #18: We don't support C3 when Type-F (fast) 747 * DMA transfers are used by any ISA device to avoid livelock. 748 * Note that we could disable Type-F DMA (as recommended by 749 * the erratum), but this is known to disrupt certain ISA 750 * devices thus we take the conservative approach. 751 */ 752 else if (errata.piix4.fdma) { 753 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 754 "C3 not supported on PIIX4 with Type-F DMA\n")); 755 return_VOID; 756 } 757 758 /* All the logic here assumes flags.bm_check is same across all CPUs */ 759 if (!bm_check_flag) { 760 /* Determine whether bm_check is needed based on CPU */ 761 acpi_processor_power_init_bm_check(&(pr->flags), pr->id); 762 bm_check_flag = pr->flags.bm_check; 763 } else { 764 pr->flags.bm_check = bm_check_flag; 765 } 766 767 if (pr->flags.bm_check) { 768 /* bus mastering control is necessary */ 769 if (!pr->flags.bm_control) { 770 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 771 "C3 support requires bus mastering control\n")); 772 return_VOID; 773 } 774 } else { 775 /* 776 * WBINVD should be set in fadt, for C3 state to be 777 * supported on when bm_check is not required. 778 */ 779 if (acpi_fadt.wb_invd != 1) { 780 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 781 "Cache invalidation should work properly" 782 " for C3 to be enabled on SMP systems\n")); 783 return_VOID; 784 } 785 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 786 0, ACPI_MTX_DO_NOT_LOCK); 787 } 788 789 /* 790 * Otherwise we've met all of our C3 requirements. 791 * Normalize the C3 latency to expidite policy. Enable 792 * checking of bus mastering status (bm_check) so we can 793 * use this in our C3 policy 794 */ 795 cx->valid = 1; 796 cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency); 797 798 return_VOID; 799 } 800 801 static int acpi_processor_power_verify(struct acpi_processor *pr) 802 { 803 unsigned int i; 804 unsigned int working = 0; 805 806 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) { 807 struct acpi_processor_cx *cx = &pr->power.states[i]; 808 809 switch (cx->type) { 810 case ACPI_STATE_C1: 811 cx->valid = 1; 812 break; 813 814 case ACPI_STATE_C2: 815 acpi_processor_power_verify_c2(cx); 816 break; 817 818 case ACPI_STATE_C3: 819 acpi_processor_power_verify_c3(pr, cx); 820 break; 821 } 822 823 if (cx->valid) 824 working++; 825 } 826 827 return (working); 828 } 829 830 static int acpi_processor_get_power_info(struct acpi_processor *pr) 831 { 832 unsigned int i; 833 int result; 834 835 ACPI_FUNCTION_TRACE("acpi_processor_get_power_info"); 836 837 /* NOTE: the idle thread may not be running while calling 838 * this function */ 839 840 result = acpi_processor_get_power_info_cst(pr); 841 if ((result) || (acpi_processor_power_verify(pr) < 2)) { 842 result = acpi_processor_get_power_info_fadt(pr); 843 if ((result) || (acpi_processor_power_verify(pr) < 2)) 844 result = acpi_processor_get_power_info_default_c1(pr); 845 } 846 847 /* 848 * Set Default Policy 849 * ------------------ 850 * Now that we know which states are supported, set the default 851 * policy. Note that this policy can be changed dynamically 852 * (e.g. encourage deeper sleeps to conserve battery life when 853 * not on AC). 854 */ 855 result = acpi_processor_set_power_policy(pr); 856 if (result) 857 return_VALUE(result); 858 859 /* 860 * if one state of type C2 or C3 is available, mark this 861 * CPU as being "idle manageable" 862 */ 863 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) { 864 if (pr->power.states[i].valid) { 865 pr->power.count = i; 866 pr->flags.power = 1; 867 } 868 } 869 870 return_VALUE(0); 871 } 872 873 int acpi_processor_cst_has_changed(struct acpi_processor *pr) 874 { 875 int result = 0; 876 877 ACPI_FUNCTION_TRACE("acpi_processor_cst_has_changed"); 878 879 if (!pr) 880 return_VALUE(-EINVAL); 881 882 if (nocst) { 883 return_VALUE(-ENODEV); 884 } 885 886 if (!pr->flags.power_setup_done) 887 return_VALUE(-ENODEV); 888 889 /* Fall back to the default idle loop */ 890 pm_idle = pm_idle_save; 891 synchronize_sched(); /* Relies on interrupts forcing exit from idle. */ 892 893 pr->flags.power = 0; 894 result = acpi_processor_get_power_info(pr); 895 if ((pr->flags.power == 1) && (pr->flags.power_setup_done)) 896 pm_idle = acpi_processor_idle; 897 898 return_VALUE(result); 899 } 900 901 /* proc interface */ 902 903 static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset) 904 { 905 struct acpi_processor *pr = (struct acpi_processor *)seq->private; 906 unsigned int i; 907 908 ACPI_FUNCTION_TRACE("acpi_processor_power_seq_show"); 909 910 if (!pr) 911 goto end; 912 913 seq_printf(seq, "active state: C%zd\n" 914 "max_cstate: C%d\n" 915 "bus master activity: %08x\n", 916 pr->power.state ? pr->power.state - pr->power.states : 0, 917 max_cstate, (unsigned)pr->power.bm_activity); 918 919 seq_puts(seq, "states:\n"); 920 921 for (i = 1; i <= pr->power.count; i++) { 922 seq_printf(seq, " %cC%d: ", 923 (&pr->power.states[i] == 924 pr->power.state ? '*' : ' '), i); 925 926 if (!pr->power.states[i].valid) { 927 seq_puts(seq, "<not supported>\n"); 928 continue; 929 } 930 931 switch (pr->power.states[i].type) { 932 case ACPI_STATE_C1: 933 seq_printf(seq, "type[C1] "); 934 break; 935 case ACPI_STATE_C2: 936 seq_printf(seq, "type[C2] "); 937 break; 938 case ACPI_STATE_C3: 939 seq_printf(seq, "type[C3] "); 940 break; 941 default: 942 seq_printf(seq, "type[--] "); 943 break; 944 } 945 946 if (pr->power.states[i].promotion.state) 947 seq_printf(seq, "promotion[C%zd] ", 948 (pr->power.states[i].promotion.state - 949 pr->power.states)); 950 else 951 seq_puts(seq, "promotion[--] "); 952 953 if (pr->power.states[i].demotion.state) 954 seq_printf(seq, "demotion[C%zd] ", 955 (pr->power.states[i].demotion.state - 956 pr->power.states)); 957 else 958 seq_puts(seq, "demotion[--] "); 959 960 seq_printf(seq, "latency[%03d] usage[%08d]\n", 961 pr->power.states[i].latency, 962 pr->power.states[i].usage); 963 } 964 965 end: 966 return_VALUE(0); 967 } 968 969 static int acpi_processor_power_open_fs(struct inode *inode, struct file *file) 970 { 971 return single_open(file, acpi_processor_power_seq_show, 972 PDE(inode)->data); 973 } 974 975 static struct file_operations acpi_processor_power_fops = { 976 .open = acpi_processor_power_open_fs, 977 .read = seq_read, 978 .llseek = seq_lseek, 979 .release = single_release, 980 }; 981 982 int acpi_processor_power_init(struct acpi_processor *pr, 983 struct acpi_device *device) 984 { 985 acpi_status status = 0; 986 static int first_run = 0; 987 struct proc_dir_entry *entry = NULL; 988 unsigned int i; 989 990 ACPI_FUNCTION_TRACE("acpi_processor_power_init"); 991 992 if (!first_run) { 993 dmi_check_system(processor_power_dmi_table); 994 if (max_cstate < ACPI_C_STATES_MAX) 995 printk(KERN_NOTICE 996 "ACPI: processor limited to max C-state %d\n", 997 max_cstate); 998 first_run++; 999 } 1000 1001 if (!pr) 1002 return_VALUE(-EINVAL); 1003 1004 if (acpi_fadt.cst_cnt && !nocst) { 1005 status = 1006 acpi_os_write_port(acpi_fadt.smi_cmd, acpi_fadt.cst_cnt, 8); 1007 if (ACPI_FAILURE(status)) { 1008 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1009 "Notifying BIOS of _CST ability failed\n")); 1010 } 1011 } 1012 1013 acpi_processor_power_init_pdc(&(pr->power), pr->id); 1014 acpi_processor_set_pdc(pr, pr->power.pdc); 1015 acpi_processor_get_power_info(pr); 1016 1017 /* 1018 * Install the idle handler if processor power management is supported. 1019 * Note that we use previously set idle handler will be used on 1020 * platforms that only support C1. 1021 */ 1022 if ((pr->flags.power) && (!boot_option_idle_override)) { 1023 printk(KERN_INFO PREFIX "CPU%d (power states:", pr->id); 1024 for (i = 1; i <= pr->power.count; i++) 1025 if (pr->power.states[i].valid) 1026 printk(" C%d[C%d]", i, 1027 pr->power.states[i].type); 1028 printk(")\n"); 1029 1030 if (pr->id == 0) { 1031 pm_idle_save = pm_idle; 1032 pm_idle = acpi_processor_idle; 1033 } 1034 } 1035 1036 /* 'power' [R] */ 1037 entry = create_proc_entry(ACPI_PROCESSOR_FILE_POWER, 1038 S_IRUGO, acpi_device_dir(device)); 1039 if (!entry) 1040 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 1041 "Unable to create '%s' fs entry\n", 1042 ACPI_PROCESSOR_FILE_POWER)); 1043 else { 1044 entry->proc_fops = &acpi_processor_power_fops; 1045 entry->data = acpi_driver_data(device); 1046 entry->owner = THIS_MODULE; 1047 } 1048 1049 pr->flags.power_setup_done = 1; 1050 1051 return_VALUE(0); 1052 } 1053 1054 int acpi_processor_power_exit(struct acpi_processor *pr, 1055 struct acpi_device *device) 1056 { 1057 ACPI_FUNCTION_TRACE("acpi_processor_power_exit"); 1058 1059 pr->flags.power_setup_done = 0; 1060 1061 if (acpi_device_dir(device)) 1062 remove_proc_entry(ACPI_PROCESSOR_FILE_POWER, 1063 acpi_device_dir(device)); 1064 1065 /* Unregister the idle handler when processor #0 is removed. */ 1066 if (pr->id == 0) { 1067 pm_idle = pm_idle_save; 1068 1069 /* 1070 * We are about to unload the current idle thread pm callback 1071 * (pm_idle), Wait for all processors to update cached/local 1072 * copies of pm_idle before proceeding. 1073 */ 1074 cpu_idle_wait(); 1075 } 1076 1077 return_VALUE(0); 1078 } 1079