git.oblomov.eu Git - linux-2.6/blob - drivers/acpi/processor_idle.c

   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/pm_qos_params.h>
  42 #include <linux/clockchips.h>
  43 #include <linux/cpuidle.h>
  44 #include <linux/cpuidle.h>
  45
  46 /*
  47  * Include the apic definitions for x86 to have the APIC timer related defines
  48  * available also for UP (on SMP it gets magically included via linux/smp.h).
  49  * asm/acpi.h is not an option, as it would require more include magic. Also
  50  * creating an empty asm-ia64/apic.h would just trade pest vs. cholera.
  51  */
  52 #ifdef CONFIG_X86
  53 #include <asm/apic.h>
  54 #endif
  55
  56 #include <asm/io.h>
  57 #include <asm/uaccess.h>
  58
  59 #include <acpi/acpi_bus.h>
  60 #include <acpi/processor.h>
  61 #include <asm/processor.h>
  62
  63 #define ACPI_PROCESSOR_COMPONENT        0x01000000
  64 #define ACPI_PROCESSOR_CLASS            "processor"
  65 #define _COMPONENT              ACPI_PROCESSOR_COMPONENT
  66 ACPI_MODULE_NAME("processor_idle");
  67 #define ACPI_PROCESSOR_FILE_POWER       "power"
  68 #define US_TO_PM_TIMER_TICKS(t)         ((t * (PM_TIMER_FREQUENCY/1000)) / 1000)
  69 #define PM_TIMER_TICK_NS                (1000000000ULL/PM_TIMER_FREQUENCY)
  70 #ifndef CONFIG_CPU_IDLE
  71 #define C2_OVERHEAD                     4       /* 1us (3.579 ticks per us) */
  72 #define C3_OVERHEAD                     4       /* 1us (3.579 ticks per us) */
  73 static void (*pm_idle_save) (void) __read_mostly;
  74 #else
  75 #define C2_OVERHEAD                     1       /* 1us */
  76 #define C3_OVERHEAD                     1       /* 1us */
  77 #endif
  78 #define PM_TIMER_TICKS_TO_US(p)         (((p) * 1000)/(PM_TIMER_FREQUENCY/1000))
  79
  80 static unsigned int max_cstate __read_mostly = ACPI_PROCESSOR_MAX_POWER;
  81 #ifdef CONFIG_CPU_IDLE
  82 module_param(max_cstate, uint, 0000);
  83 #else
  84 module_param(max_cstate, uint, 0644);
  85 #endif
  86 static unsigned int nocst __read_mostly;
  87 module_param(nocst, uint, 0000);
  88
  89 #ifndef CONFIG_CPU_IDLE
  90 /*
  91  * bm_history -- bit-mask with a bit per jiffy of bus-master activity
  92  * 1000 HZ: 0xFFFFFFFF: 32 jiffies = 32ms
  93  * 800 HZ: 0xFFFFFFFF: 32 jiffies = 40ms
  94  * 100 HZ: 0x0000000F: 4 jiffies = 40ms
  95  * reduce history for more aggressive entry into C3
  96  */
  97 static unsigned int bm_history __read_mostly =
  98     (HZ >= 800 ? 0xFFFFFFFF : ((1U << (HZ / 25)) - 1));
  99 module_param(bm_history, uint, 0644);
 100
 101 static int acpi_processor_set_power_policy(struct acpi_processor *pr);
 102
 103 #else   /* CONFIG_CPU_IDLE */
 104 static unsigned int latency_factor __read_mostly = 2;
 105 module_param(latency_factor, uint, 0644);
 106 #endif
 107
 108 /*
 109  * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3.
 110  * For now disable this. Probably a bug somewhere else.
 111  *
 112  * To skip this limit, boot/load with a large max_cstate limit.
 113  */
 114 static int set_max_cstate(const struct dmi_system_id *id)
 115 {
 116         if (max_cstate > ACPI_PROCESSOR_MAX_POWER)
 117                 return 0;
 118
 119         printk(KERN_NOTICE PREFIX "%s detected - limiting to C%ld max_cstate."
 120                " Override with \"processor.max_cstate=%d\"\n", id->ident,
 121                (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1);
 122
 123         max_cstate = (long)id->driver_data;
 124
 125         return 0;
 126 }
 127
 128 /* Actually this shouldn't be __cpuinitdata, would be better to fix the
 129    callers to only run once -AK */
 130 static struct dmi_system_id __cpuinitdata processor_power_dmi_table[] = {
 131         { set_max_cstate, "IBM ThinkPad R40e", {
 132           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 133           DMI_MATCH(DMI_BIOS_VERSION,"1SET70WW")}, (void *)1},
 134         { set_max_cstate, "IBM ThinkPad R40e", {
 135           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 136           DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW")}, (void *)1},
 137         { set_max_cstate, "IBM ThinkPad R40e", {
 138           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 139           DMI_MATCH(DMI_BIOS_VERSION,"1SET43WW") }, (void*)1},
 140         { set_max_cstate, "IBM ThinkPad R40e", {
 141           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 142           DMI_MATCH(DMI_BIOS_VERSION,"1SET45WW") }, (void*)1},
 143         { set_max_cstate, "IBM ThinkPad R40e", {
 144           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 145           DMI_MATCH(DMI_BIOS_VERSION,"1SET47WW") }, (void*)1},
 146         { set_max_cstate, "IBM ThinkPad R40e", {
 147           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 148           DMI_MATCH(DMI_BIOS_VERSION,"1SET50WW") }, (void*)1},
 149         { set_max_cstate, "IBM ThinkPad R40e", {
 150           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 151           DMI_MATCH(DMI_BIOS_VERSION,"1SET52WW") }, (void*)1},
 152         { set_max_cstate, "IBM ThinkPad R40e", {
 153           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 154           DMI_MATCH(DMI_BIOS_VERSION,"1SET55WW") }, (void*)1},
 155         { set_max_cstate, "IBM ThinkPad R40e", {
 156           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 157           DMI_MATCH(DMI_BIOS_VERSION,"1SET56WW") }, (void*)1},
 158         { set_max_cstate, "IBM ThinkPad R40e", {
 159           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 160           DMI_MATCH(DMI_BIOS_VERSION,"1SET59WW") }, (void*)1},
 161         { set_max_cstate, "IBM ThinkPad R40e", {
 162           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 163           DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW") }, (void*)1},
 164         { set_max_cstate, "IBM ThinkPad R40e", {
 165           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 166           DMI_MATCH(DMI_BIOS_VERSION,"1SET61WW") }, (void*)1},
 167         { set_max_cstate, "IBM ThinkPad R40e", {
 168           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 169           DMI_MATCH(DMI_BIOS_VERSION,"1SET62WW") }, (void*)1},
 170         { set_max_cstate, "IBM ThinkPad R40e", {
 171           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 172           DMI_MATCH(DMI_BIOS_VERSION,"1SET64WW") }, (void*)1},
 173         { set_max_cstate, "IBM ThinkPad R40e", {
 174           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 175           DMI_MATCH(DMI_BIOS_VERSION,"1SET65WW") }, (void*)1},
 176         { set_max_cstate, "IBM ThinkPad R40e", {
 177           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
 178           DMI_MATCH(DMI_BIOS_VERSION,"1SET68WW") }, (void*)1},
 179         { set_max_cstate, "Medion 41700", {
 180           DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
 181           DMI_MATCH(DMI_BIOS_VERSION,"R01-A1J")}, (void *)1},
 182         { set_max_cstate, "Clevo 5600D", {
 183           DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
 184           DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")},
 185          (void *)2},
 186         {},
 187 };
 188
 189 static inline u32 ticks_elapsed(u32 t1, u32 t2)
 190 {
 191         if (t2 >= t1)
 192                 return (t2 - t1);
 193         else if (!(acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER))
 194                 return (((0x00FFFFFF - t1) + t2) & 0x00FFFFFF);
 195         else
 196                 return ((0xFFFFFFFF - t1) + t2);
 197 }
 198
 199 static inline u32 ticks_elapsed_in_us(u32 t1, u32 t2)
 200 {
 201         if (t2 >= t1)
 202                 return PM_TIMER_TICKS_TO_US(t2 - t1);
 203         else if (!(acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER))
 204                 return PM_TIMER_TICKS_TO_US(((0x00FFFFFF - t1) + t2) & 0x00FFFFFF);
 205         else
 206                 return PM_TIMER_TICKS_TO_US((0xFFFFFFFF - t1) + t2);
 207 }
 208
 209 /*
 210  * Callers should disable interrupts before the call and enable
 211  * interrupts after return.
 212  */
 213 static void acpi_safe_halt(void)
 214 {
 215         current_thread_info()->status &= ~TS_POLLING;
 216         /*
 217          * TS_POLLING-cleared state must be visible before we
 218          * test NEED_RESCHED:
 219          */
 220         smp_mb();
 221         if (!need_resched()) {
 222                 safe_halt();
 223                 local_irq_disable();
 224         }
 225         current_thread_info()->status |= TS_POLLING;
 226 }
 227
 228 #ifndef CONFIG_CPU_IDLE
 229
 230 static void
 231 acpi_processor_power_activate(struct acpi_processor *pr,
 232                               struct acpi_processor_cx *new)
 233 {
 234         struct acpi_processor_cx *old;
 235
 236         if (!pr || !new)
 237                 return;
 238
 239         old = pr->power.state;
 240
 241         if (old)
 242                 old->promotion.count = 0;
 243         new->demotion.count = 0;
 244
 245         /* Cleanup from old state. */
 246         if (old) {
 247                 switch (old->type) {
 248                 case ACPI_STATE_C3:
 249                         /* Disable bus master reload */
 250                         if (new->type != ACPI_STATE_C3 && pr->flags.bm_check)
 251                                 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 0);
 252                         break;
 253                 }
 254         }
 255
 256         /* Prepare to use new state. */
 257         switch (new->type) {
 258         case ACPI_STATE_C3:
 259                 /* Enable bus master reload */
 260                 if (old->type != ACPI_STATE_C3 && pr->flags.bm_check)
 261                         acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 1);
 262                 break;
 263         }
 264
 265         pr->power.state = new;
 266
 267         return;
 268 }
 269
 270 static atomic_t c3_cpu_count;
 271
 272 /* Common C-state entry for C2, C3, .. */
 273 static void acpi_cstate_enter(struct acpi_processor_cx *cstate)
 274 {
 275         if (cstate->entry_method == ACPI_CSTATE_FFH) {
 276                 /* Call into architectural FFH based C-state */
 277                 acpi_processor_ffh_cstate_enter(cstate);
 278         } else {
 279                 int unused;
 280                 /* IO port based C-state */
 281                 inb(cstate->address);
 282                 /* Dummy wait op - must do something useless after P_LVL2 read
 283                    because chipsets cannot guarantee that STPCLK# signal
 284                    gets asserted in time to freeze execution properly. */
 285                 unused = inl(acpi_gbl_FADT.xpm_timer_block.address);
 286         }
 287 }
 288 #endif /* !CONFIG_CPU_IDLE */
 289
 290 #ifdef ARCH_APICTIMER_STOPS_ON_C3
 291
 292 /*
 293  * Some BIOS implementations switch to C3 in the published C2 state.
 294  * This seems to be a common problem on AMD boxen, but other vendors
 295  * are affected too. We pick the most conservative approach: we assume
 296  * that the local APIC stops in both C2 and C3.
 297  */
 298 static void acpi_timer_check_state(int state, struct acpi_processor *pr,
 299                                    struct acpi_processor_cx *cx)
 300 {
 301         struct acpi_processor_power *pwr = &pr->power;
 302         u8 type = local_apic_timer_c2_ok ? ACPI_STATE_C3 : ACPI_STATE_C2;
 303
 304         /*
 305          * Check, if one of the previous states already marked the lapic
 306          * unstable
 307          */
 308         if (pwr->timer_broadcast_on_state < state)
 309                 return;
 310
 311         if (cx->type >= type)
 312                 pr->power.timer_broadcast_on_state = state;
 313 }
 314
 315 static void acpi_propagate_timer_broadcast(struct acpi_processor *pr)
 316 {
 317         unsigned long reason;
 318
 319         reason = pr->power.timer_broadcast_on_state < INT_MAX ?
 320                 CLOCK_EVT_NOTIFY_BROADCAST_ON : CLOCK_EVT_NOTIFY_BROADCAST_OFF;
 321
 322         clockevents_notify(reason, &pr->id);
 323 }
 324
 325 /* Power(C) State timer broadcast control */
 326 static void acpi_state_timer_broadcast(struct acpi_processor *pr,
 327                                        struct acpi_processor_cx *cx,
 328                                        int broadcast)
 329 {
 330         int state = cx - pr->power.states;
 331
 332         if (state >= pr->power.timer_broadcast_on_state) {
 333                 unsigned long reason;
 334
 335                 reason = broadcast ?  CLOCK_EVT_NOTIFY_BROADCAST_ENTER :
 336                         CLOCK_EVT_NOTIFY_BROADCAST_EXIT;
 337                 clockevents_notify(reason, &pr->id);
 338         }
 339 }
 340
 341 #else
 342
 343 static void acpi_timer_check_state(int state, struct acpi_processor *pr,
 344                                    struct acpi_processor_cx *cstate) { }
 345 static void acpi_propagate_timer_broadcast(struct acpi_processor *pr) { }
 346 static void acpi_state_timer_broadcast(struct acpi_processor *pr,
 347                                        struct acpi_processor_cx *cx,
 348                                        int broadcast)
 349 {
 350 }
 351
 352 #endif
 353
 354 /*
 355  * Suspend / resume control
 356  */
 357 static int acpi_idle_suspend;
 358
 359 int acpi_processor_suspend(struct acpi_device * device, pm_message_t state)
 360 {
 361         acpi_idle_suspend = 1;
 362         return 0;
 363 }
 364
 365 int acpi_processor_resume(struct acpi_device * device)
 366 {
 367         acpi_idle_suspend = 0;
 368         return 0;
 369 }
 370
 371 #if defined (CONFIG_GENERIC_TIME) && defined (CONFIG_X86)
 372 static int tsc_halts_in_c(int state)
 373 {
 374         switch (boot_cpu_data.x86_vendor) {
 375         case X86_VENDOR_AMD:
 376                 /*
 377                  * AMD Fam10h TSC will tick in all
 378                  * C/P/S0/S1 states when this bit is set.
 379                  */
 380                 if (boot_cpu_has(X86_FEATURE_CONSTANT_TSC))
 381                         return 0;
 382                 /*FALL THROUGH*/
 383         case X86_VENDOR_INTEL:
 384                 /* Several cases known where TSC halts in C2 too */
 385         default:
 386                 return state > ACPI_STATE_C1;
 387         }
 388 }
 389 #endif
 390
 391 #ifndef CONFIG_CPU_IDLE
 392 static void acpi_processor_idle(void)
 393 {
 394         struct acpi_processor *pr = NULL;
 395         struct acpi_processor_cx *cx = NULL;
 396         struct acpi_processor_cx *next_state = NULL;
 397         int sleep_ticks = 0;
 398         u32 t1, t2 = 0;
 399
 400         /*
 401          * Interrupts must be disabled during bus mastering calculations and
 402          * for C2/C3 transitions.
 403          */
 404         local_irq_disable();
 405
 406         pr = __get_cpu_var(processors);
 407         if (!pr) {
 408                 local_irq_enable();
 409                 return;
 410         }
 411
 412         /*
 413          * Check whether we truly need to go idle, or should
 414          * reschedule:
 415          */
 416         if (unlikely(need_resched())) {
 417                 local_irq_enable();
 418                 return;
 419         }
 420
 421         cx = pr->power.state;
 422         if (!cx || acpi_idle_suspend) {
 423                 if (pm_idle_save) {
 424                         pm_idle_save(); /* enables IRQs */
 425                 } else {
 426                         acpi_safe_halt();
 427                         local_irq_enable();
 428                 }
 429
 430                 return;
 431         }
 432
 433         /*
 434          * Check BM Activity
 435          * -----------------
 436          * Check for bus mastering activity (if required), record, and check
 437          * for demotion.
 438          */
 439         if (pr->flags.bm_check) {
 440                 u32 bm_status = 0;
 441                 unsigned long diff = jiffies - pr->power.bm_check_timestamp;
 442
 443                 if (diff > 31)
 444                         diff = 31;
 445
 446                 pr->power.bm_activity <<= diff;
 447
 448                 acpi_get_register(ACPI_BITREG_BUS_MASTER_STATUS, &bm_status);
 449                 if (bm_status) {
 450                         pr->power.bm_activity |= 0x1;
 451                         acpi_set_register(ACPI_BITREG_BUS_MASTER_STATUS, 1);
 452                 }
 453                 /*
 454                  * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect
 455                  * the true state of bus mastering activity; forcing us to
 456                  * manually check the BMIDEA bit of each IDE channel.
 457                  */
 458                 else if (errata.piix4.bmisx) {
 459                         if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01)
 460                             || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01))
 461                                 pr->power.bm_activity |= 0x1;
 462                 }
 463
 464                 pr->power.bm_check_timestamp = jiffies;
 465
 466                 /*
 467                  * If bus mastering is or was active this jiffy, demote
 468                  * to avoid a faulty transition.  Note that the processor
 469                  * won't enter a low-power state during this call (to this
 470                  * function) but should upon the next.
 471                  *
 472                  * TBD: A better policy might be to fallback to the demotion
 473                  *      state (use it for this quantum only) istead of
 474                  *      demoting -- and rely on duration as our sole demotion
 475                  *      qualification.  This may, however, introduce DMA
 476                  *      issues (e.g. floppy DMA transfer overrun/underrun).
 477                  */
 478                 if ((pr->power.bm_activity & 0x1) &&
 479                     cx->demotion.threshold.bm) {
 480                         local_irq_enable();
 481                         next_state = cx->demotion.state;
 482                         goto end;
 483                 }
 484         }
 485
 486 #ifdef CONFIG_HOTPLUG_CPU
 487         /*
 488          * Check for P_LVL2_UP flag before entering C2 and above on
 489          * an SMP system. We do it here instead of doing it at _CST/P_LVL
 490          * detection phase, to work cleanly with logical CPU hotplug.
 491          */
 492         if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) &&
 493             !pr->flags.has_cst && !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
 494                 cx = &pr->power.states[ACPI_STATE_C1];
 495 #endif
 496
 497         /*
 498          * Sleep:
 499          * ------
 500          * Invoke the current Cx state to put the processor to sleep.
 501          */
 502         if (cx->type == ACPI_STATE_C2 || cx->type == ACPI_STATE_C3) {
 503                 current_thread_info()->status &= ~TS_POLLING;
 504                 /*
 505                  * TS_POLLING-cleared state must be visible before we
 506                  * test NEED_RESCHED:
 507                  */
 508                 smp_mb();
 509                 if (need_resched()) {
 510                         current_thread_info()->status |= TS_POLLING;
 511                         local_irq_enable();
 512                         return;
 513                 }
 514         }
 515
 516         switch (cx->type) {
 517
 518         case ACPI_STATE_C1:
 519                 /*
 520                  * Invoke C1.
 521                  * Use the appropriate idle routine, the one that would
 522                  * be used without acpi C-states.
 523                  */
 524                 if (pm_idle_save) {
 525                         pm_idle_save(); /* enables IRQs */
 526                 } else {
 527                         acpi_safe_halt();
 528                         local_irq_enable();
 529                 }
 530
 531                 /*
 532                  * TBD: Can't get time duration while in C1, as resumes
 533                  *      go to an ISR rather than here.  Need to instrument
 534                  *      base interrupt handler.
 535                  *
 536                  * Note: the TSC better not stop in C1, sched_clock() will
 537                  *       skew otherwise.
 538                  */
 539                 sleep_ticks = 0xFFFFFFFF;
 540
 541                 break;
 542
 543         case ACPI_STATE_C2:
 544                 /* Get start time (ticks) */
 545                 t1 = inl(acpi_gbl_FADT.xpm_timer_block.address);
 546                 /* Tell the scheduler that we are going deep-idle: */
 547                 sched_clock_idle_sleep_event();
 548                 /* Invoke C2 */
 549                 acpi_state_timer_broadcast(pr, cx, 1);
 550                 acpi_cstate_enter(cx);
 551                 /* Get end time (ticks) */
 552                 t2 = inl(acpi_gbl_FADT.xpm_timer_block.address);
 553
 554 #if defined (CONFIG_GENERIC_TIME) && defined (CONFIG_X86)
 555                 /* TSC halts in C2, so notify users */
 556                 if (tsc_halts_in_c(ACPI_STATE_C2))
 557                         mark_tsc_unstable("possible TSC halt in C2");
 558 #endif
 559                 /* Compute time (ticks) that we were actually asleep */
 560                 sleep_ticks = ticks_elapsed(t1, t2);
 561
 562                 /* Tell the scheduler how much we idled: */
 563                 sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS);
 564
 565                 /* Re-enable interrupts */
 566                 local_irq_enable();
 567                 /* Do not account our idle-switching overhead: */
 568                 sleep_ticks -= cx->latency_ticks + C2_OVERHEAD;
 569
 570                 current_thread_info()->status |= TS_POLLING;
 571                 acpi_state_timer_broadcast(pr, cx, 0);
 572                 break;
 573
 574         case ACPI_STATE_C3:
 575                 acpi_unlazy_tlb(smp_processor_id());
 576                 /*
 577                  * Must be done before busmaster disable as we might
 578                  * need to access HPET !
 579                  */
 580                 acpi_state_timer_broadcast(pr, cx, 1);
 581                 /*
 582                  * disable bus master
 583                  * bm_check implies we need ARB_DIS
 584                  * !bm_check implies we need cache flush
 585                  * bm_control implies whether we can do ARB_DIS
 586                  *
 587                  * That leaves a case where bm_check is set and bm_control is
 588                  * not set. In that case we cannot do much, we enter C3
 589                  * without doing anything.
 590                  */
 591                 if (pr->flags.bm_check && pr->flags.bm_control) {
 592                         if (atomic_inc_return(&c3_cpu_count) ==
 593                             num_online_cpus()) {
 594                                 /*
 595                                  * All CPUs are trying to go to C3
 596                                  * Disable bus master arbitration
 597                                  */
 598                                 acpi_set_register(ACPI_BITREG_ARB_DISABLE, 1);
 599                         }
 600                 } else if (!pr->flags.bm_check) {
 601                         /* SMP with no shared cache... Invalidate cache  */
 602                         ACPI_FLUSH_CPU_CACHE();
 603                 }
 604
 605                 /* Get start time (ticks) */
 606                 t1 = inl(acpi_gbl_FADT.xpm_timer_block.address);
 607                 /* Invoke C3 */
 608                 /* Tell the scheduler that we are going deep-idle: */
 609                 sched_clock_idle_sleep_event();
 610                 acpi_cstate_enter(cx);
 611                 /* Get end time (ticks) */
 612                 t2 = inl(acpi_gbl_FADT.xpm_timer_block.address);
 613                 if (pr->flags.bm_check && pr->flags.bm_control) {
 614                         /* Enable bus master arbitration */
 615                         atomic_dec(&c3_cpu_count);
 616                         acpi_set_register(ACPI_BITREG_ARB_DISABLE, 0);
 617                 }
 618
 619 #if defined (CONFIG_GENERIC_TIME) && defined (CONFIG_X86)
 620                 /* TSC halts in C3, so notify users */
 621                 if (tsc_halts_in_c(ACPI_STATE_C3))
 622                         mark_tsc_unstable("TSC halts in C3");
 623 #endif
 624                 /* Compute time (ticks) that we were actually asleep */
 625                 sleep_ticks = ticks_elapsed(t1, t2);
 626                 /* Tell the scheduler how much we idled: */
 627                 sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS);
 628
 629                 /* Re-enable interrupts */
 630                 local_irq_enable();
 631                 /* Do not account our idle-switching overhead: */
 632                 sleep_ticks -= cx->latency_ticks + C3_OVERHEAD;
 633
 634                 current_thread_info()->status |= TS_POLLING;
 635                 acpi_state_timer_broadcast(pr, cx, 0);
 636                 break;
 637
 638         default:
 639                 local_irq_enable();
 640                 return;
 641         }
 642         cx->usage++;
 643         if ((cx->type != ACPI_STATE_C1) && (sleep_ticks > 0))
 644                 cx->time += sleep_ticks;
 645
 646         next_state = pr->power.state;
 647
 648 #ifdef CONFIG_HOTPLUG_CPU
 649         /* Don't do promotion/demotion */
 650         if ((cx->type == ACPI_STATE_C1) && (num_online_cpus() > 1) &&
 651             !pr->flags.has_cst && !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED)) {
 652                 next_state = cx;
 653                 goto end;
 654         }
 655 #endif
 656
 657         /*
 658          * Promotion?
 659          * ----------
 660          * Track the number of longs (time asleep is greater than threshold)
 661          * and promote when the count threshold is reached.  Note that bus
 662          * mastering activity may prevent promotions.
 663          * Do not promote above max_cstate.
 664          */
 665         if (cx->promotion.state &&
 666             ((cx->promotion.state - pr->power.states) <= max_cstate)) {
 667                 if (sleep_ticks > cx->promotion.threshold.ticks &&
 668                   cx->promotion.state->latency <=
 669                                 pm_qos_requirement(PM_QOS_CPU_DMA_LATENCY)) {
 670                         cx->promotion.count++;
 671                         cx->demotion.count = 0;
 672                         if (cx->promotion.count >=
 673                             cx->promotion.threshold.count) {
 674                                 if (pr->flags.bm_check) {
 675                                         if (!
 676                                             (pr->power.bm_activity & cx->
 677                                              promotion.threshold.bm)) {
 678                                                 next_state =
 679                                                     cx->promotion.state;
 680                                                 goto end;
 681                                         }
 682                                 } else {
 683                                         next_state = cx->promotion.state;
 684                                         goto end;
 685                                 }
 686                         }
 687                 }
 688         }
 689
 690         /*
 691          * Demotion?
 692          * ---------
 693          * Track the number of shorts (time asleep is less than time threshold)
 694          * and demote when the usage threshold is reached.
 695          */
 696         if (cx->demotion.state) {
 697                 if (sleep_ticks < cx->demotion.threshold.ticks) {
 698                         cx->demotion.count++;
 699                         cx->promotion.count = 0;
 700                         if (cx->demotion.count >= cx->demotion.threshold.count) {
 701                                 next_state = cx->demotion.state;
 702                                 goto end;
 703                         }
 704                 }
 705         }
 706
 707       end:
 708         /*
 709          * Demote if current state exceeds max_cstate
 710          * or if the latency of the current state is unacceptable
 711          */
 712         if ((pr->power.state - pr->power.states) > max_cstate ||
 713                 pr->power.state->latency >
 714                                 pm_qos_requirement(PM_QOS_CPU_DMA_LATENCY)) {
 715                 if (cx->demotion.state)
 716                         next_state = cx->demotion.state;
 717         }
 718
 719         /*
 720          * New Cx State?
 721          * -------------
 722          * If we're going to start using a new Cx state we must clean up
 723          * from the previous and prepare to use the new.
 724          */
 725         if (next_state != pr->power.state)
 726                 acpi_processor_power_activate(pr, next_state);
 727 }
 728
 729 static int acpi_processor_set_power_policy(struct acpi_processor *pr)
 730 {
 731         unsigned int i;
 732         unsigned int state_is_set = 0;
 733         struct acpi_processor_cx *lower = NULL;
 734         struct acpi_processor_cx *higher = NULL;
 735         struct acpi_processor_cx *cx;
 736
 737
 738         if (!pr)
 739                 return -EINVAL;
 740
 741         /*
 742          * This function sets the default Cx state policy (OS idle handler).
 743          * Our scheme is to promote quickly to C2 but more conservatively
 744          * to C3.  We're favoring C2  for its characteristics of low latency
 745          * (quick response), good power savings, and ability to allow bus
 746          * mastering activity.  Note that the Cx state policy is completely
 747          * customizable and can be altered dynamically.
 748          */
 749
 750         /* startup state */
 751         for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
 752                 cx = &pr->power.states[i];
 753                 if (!cx->valid)
 754                         continue;
 755
 756                 if (!state_is_set)
 757                         pr->power.state = cx;
 758                 state_is_set++;
 759                 break;
 760         }
 761
 762         if (!state_is_set)
 763                 return -ENODEV;
 764
 765         /* demotion */
 766         for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
 767                 cx = &pr->power.states[i];
 768                 if (!cx->valid)
 769                         continue;
 770
 771                 if (lower) {
 772                         cx->demotion.state = lower;
 773                         cx->demotion.threshold.ticks = cx->latency_ticks;
 774                         cx->demotion.threshold.count = 1;
 775                         if (cx->type == ACPI_STATE_C3)
 776                                 cx->demotion.threshold.bm = bm_history;
 777                 }
 778
 779                 lower = cx;
 780         }
 781
 782         /* promotion */
 783         for (i = (ACPI_PROCESSOR_MAX_POWER - 1); i > 0; i--) {
 784                 cx = &pr->power.states[i];
 785                 if (!cx->valid)
 786                         continue;
 787
 788                 if (higher) {
 789                         cx->promotion.state = higher;
 790                         cx->promotion.threshold.ticks = cx->latency_ticks;
 791                         if (cx->type >= ACPI_STATE_C2)
 792                                 cx->promotion.threshold.count = 4;
 793                         else
 794                                 cx->promotion.threshold.count = 10;
 795                         if (higher->type == ACPI_STATE_C3)
 796                                 cx->promotion.threshold.bm = bm_history;
 797                 }
 798
 799                 higher = cx;
 800         }
 801
 802         return 0;
 803 }
 804 #endif /* !CONFIG_CPU_IDLE */
 805
 806 static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
 807 {
 808
 809         if (!pr)
 810                 return -EINVAL;
 811
 812         if (!pr->pblk)
 813                 return -ENODEV;
 814
 815         /* if info is obtained from pblk/fadt, type equals state */
 816         pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2;
 817         pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3;
 818
 819 #ifndef CONFIG_HOTPLUG_CPU
 820         /*
 821          * Check for P_LVL2_UP flag before entering C2 and above on
 822          * an SMP system.
 823          */
 824         if ((num_online_cpus() > 1) &&
 825             !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
 826                 return -ENODEV;
 827 #endif
 828
 829         /* determine C2 and C3 address from pblk */
 830         pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4;
 831         pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5;
 832
 833         /* determine latencies from FADT */
 834         pr->power.states[ACPI_STATE_C2].latency = acpi_gbl_FADT.C2latency;
 835         pr->power.states[ACPI_STATE_C3].latency = acpi_gbl_FADT.C3latency;
 836
 837         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 838                           "lvl2[0x%08x] lvl3[0x%08x]\n",
 839                           pr->power.states[ACPI_STATE_C2].address,
 840                           pr->power.states[ACPI_STATE_C3].address));
 841
 842         return 0;
 843 }
 844
 845 static int acpi_processor_get_power_info_default(struct acpi_processor *pr)
 846 {
 847         if (!pr->power.states[ACPI_STATE_C1].valid) {
 848                 /* set the first C-State to C1 */
 849                 /* all processors need to support C1 */
 850                 pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1;
 851                 pr->power.states[ACPI_STATE_C1].valid = 1;
 852                 pr->power.states[ACPI_STATE_C1].entry_method = ACPI_CSTATE_HALT;
 853         }
 854         /* the C0 state only exists as a filler in our array */
 855         pr->power.states[ACPI_STATE_C0].valid = 1;
 856         return 0;
 857 }
 858
 859 static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
 860 {
 861         acpi_status status = 0;
 862         acpi_integer count;
 863         int current_count;
 864         int i;
 865         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 866         union acpi_object *cst;
 867
 868
 869         if (nocst)
 870                 return -ENODEV;
 871
 872         current_count = 0;
 873
 874         status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer);
 875         if (ACPI_FAILURE(status)) {
 876                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _CST, giving up\n"));
 877                 return -ENODEV;
 878         }
 879
 880         cst = buffer.pointer;
 881
 882         /* There must be at least 2 elements */
 883         if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) {
 884                 printk(KERN_ERR PREFIX "not enough elements in _CST\n");
 885                 status = -EFAULT;
 886                 goto end;
 887         }
 888
 889         count = cst->package.elements[0].integer.value;
 890
 891         /* Validate number of power states. */
 892         if (count < 1 || count != cst->package.count - 1) {
 893                 printk(KERN_ERR PREFIX "count given by _CST is not valid\n");
 894                 status = -EFAULT;
 895                 goto end;
 896         }
 897
 898         /* Tell driver that at least _CST is supported. */
 899         pr->flags.has_cst = 1;
 900
 901         for (i = 1; i <= count; i++) {
 902                 union acpi_object *element;
 903                 union acpi_object *obj;
 904                 struct acpi_power_register *reg;
 905                 struct acpi_processor_cx cx;
 906
 907                 memset(&cx, 0, sizeof(cx));
 908
 909                 element = &(cst->package.elements[i]);
 910                 if (element->type != ACPI_TYPE_PACKAGE)
 911                         continue;
 912
 913                 if (element->package.count != 4)
 914                         continue;
 915
 916                 obj = &(element->package.elements[0]);
 917
 918                 if (obj->type != ACPI_TYPE_BUFFER)
 919                         continue;
 920
 921                 reg = (struct acpi_power_register *)obj->buffer.pointer;
 922
 923                 if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO &&
 924                     (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE))
 925                         continue;
 926
 927                 /* There should be an easy way to extract an integer... */
 928                 obj = &(element->package.elements[1]);
 929                 if (obj->type != ACPI_TYPE_INTEGER)
 930                         continue;
 931
 932                 cx.type = obj->integer.value;
 933                 /*
 934                  * Some buggy BIOSes won't list C1 in _CST -
 935                  * Let acpi_processor_get_power_info_default() handle them later
 936                  */
 937                 if (i == 1 && cx.type != ACPI_STATE_C1)
 938                         current_count++;
 939
 940                 cx.address = reg->address;
 941                 cx.index = current_count + 1;
 942
 943                 cx.entry_method = ACPI_CSTATE_SYSTEMIO;
 944                 if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
 945                         if (acpi_processor_ffh_cstate_probe
 946                                         (pr->id, &cx, reg) == 0) {
 947                                 cx.entry_method = ACPI_CSTATE_FFH;
 948                         } else if (cx.type == ACPI_STATE_C1) {
 949                                 /*
 950                                  * C1 is a special case where FIXED_HARDWARE
 951                                  * can be handled in non-MWAIT way as well.
 952                                  * In that case, save this _CST entry info.
 953                                  * Otherwise, ignore this info and continue.
 954                                  */
 955                                 cx.entry_method = ACPI_CSTATE_HALT;
 956                                 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
 957                         } else {
 958                                 continue;
 959                         }
 960                         if (cx.type == ACPI_STATE_C1 &&
 961                                         (idle_halt || idle_nomwait)) {
 962                                 /*
 963                                  * In most cases the C1 space_id obtained from
 964                                  * _CST object is FIXED_HARDWARE access mode.
 965                                  * But when the option of idle=halt is added,
 966                                  * the entry_method type should be changed from
 967                                  * CSTATE_FFH to CSTATE_HALT.
 968                                  * When the option of idle=nomwait is added,
 969                                  * the C1 entry_method type should be
 970                                  * CSTATE_HALT.
 971                                  */
 972                                 cx.entry_method = ACPI_CSTATE_HALT;
 973                                 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
 974                         }
 975                 } else {
 976                         snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI IOPORT 0x%x",
 977                                  cx.address);
 978                 }
 979
 980                 if (cx.type == ACPI_STATE_C1) {
 981                         cx.valid = 1;
 982                 }
 983
 984                 obj = &(element->package.elements[2]);
 985                 if (obj->type != ACPI_TYPE_INTEGER)
 986                         continue;
 987
 988                 cx.latency = obj->integer.value;
 989
 990                 obj = &(element->package.elements[3]);
 991                 if (obj->type != ACPI_TYPE_INTEGER)
 992                         continue;
 993
 994                 cx.power = obj->integer.value;
 995
 996                 current_count++;
 997                 memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx));
 998
 999                 /*
1000                  * We support total ACPI_PROCESSOR_MAX_POWER - 1
1001                  * (From 1 through ACPI_PROCESSOR_MAX_POWER - 1)
1002                  */
1003                 if (current_count >= (ACPI_PROCESSOR_MAX_POWER - 1)) {
1004                         printk(KERN_WARNING
1005                                "Limiting number of power states to max (%d)\n",
1006                                ACPI_PROCESSOR_MAX_POWER);
1007                         printk(KERN_WARNING
1008                                "Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n");
1009                         break;
1010                 }
1011         }
1012
1013         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n",
1014                           current_count));
1015
1016         /* Validate number of power states discovered */
1017         if (current_count < 2)
1018                 status = -EFAULT;
1019
1020       end:
1021         kfree(buffer.pointer);
1022
1023         return status;
1024 }
1025
1026 static void acpi_processor_power_verify_c2(struct acpi_processor_cx *cx)
1027 {
1028
1029         if (!cx->address)
1030                 return;
1031
1032         /*
1033          * C2 latency must be less than or equal to 100
1034          * microseconds.
1035          */
1036         else if (cx->latency > ACPI_PROCESSOR_MAX_C2_LATENCY) {
1037                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1038                                   "latency too large [%d]\n", cx->latency));
1039                 return;
1040         }
1041
1042         /*
1043          * Otherwise we've met all of our C2 requirements.
1044          * Normalize the C2 latency to expidite policy
1045          */
1046         cx->valid = 1;
1047
1048 #ifndef CONFIG_CPU_IDLE
1049         cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency);
1050 #else
1051         cx->latency_ticks = cx->latency;
1052 #endif
1053
1054         return;
1055 }
1056
1057 static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
1058                                            struct acpi_processor_cx *cx)
1059 {
1060         static int bm_check_flag;
1061
1062
1063         if (!cx->address)
1064                 return;
1065
1066         /*
1067          * C3 latency must be less than or equal to 1000
1068          * microseconds.
1069          */
1070         else if (cx->latency > ACPI_PROCESSOR_MAX_C3_LATENCY) {
1071                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1072                                   "latency too large [%d]\n", cx->latency));
1073                 return;
1074         }
1075
1076         /*
1077          * PIIX4 Erratum #18: We don't support C3 when Type-F (fast)
1078          * DMA transfers are used by any ISA device to avoid livelock.
1079          * Note that we could disable Type-F DMA (as recommended by
1080          * the erratum), but this is known to disrupt certain ISA
1081          * devices thus we take the conservative approach.
1082          */
1083         else if (errata.piix4.fdma) {
1084                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1085                                   "C3 not supported on PIIX4 with Type-F DMA\n"));
1086                 return;
1087         }
1088
1089         /* All the logic here assumes flags.bm_check is same across all CPUs */
1090         if (!bm_check_flag) {
1091                 /* Determine whether bm_check is needed based on CPU  */
1092                 acpi_processor_power_init_bm_check(&(pr->flags), pr->id);
1093                 bm_check_flag = pr->flags.bm_check;
1094         } else {
1095                 pr->flags.bm_check = bm_check_flag;
1096         }
1097
1098         if (pr->flags.bm_check) {
1099                 if (!pr->flags.bm_control) {
1100                         if (pr->flags.has_cst != 1) {
1101                                 /* bus mastering control is necessary */
1102                                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1103                                         "C3 support requires BM control\n"));
1104                                 return;
1105                         } else {
1106                                 /* Here we enter C3 without bus mastering */
1107                                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1108                                         "C3 support without BM control\n"));
1109                         }
1110                 }
1111         } else {
1112                 /*
1113                  * WBINVD should be set in fadt, for C3 state to be
1114                  * supported on when bm_check is not required.
1115                  */
1116                 if (!(acpi_gbl_FADT.flags & ACPI_FADT_WBINVD)) {
1117                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1118                                           "Cache invalidation should work properly"
1119                                           " for C3 to be enabled on SMP systems\n"));
1120                         return;
1121                 }
1122                 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 0);
1123         }
1124
1125         /*
1126          * Otherwise we've met all of our C3 requirements.
1127          * Normalize the C3 latency to expidite policy.  Enable
1128          * checking of bus mastering status (bm_check) so we can
1129          * use this in our C3 policy
1130          */
1131         cx->valid = 1;
1132
1133 #ifndef CONFIG_CPU_IDLE
1134         cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency);
1135 #else
1136         cx->latency_ticks = cx->latency;
1137 #endif
1138
1139         return;
1140 }
1141
1142 static int acpi_processor_power_verify(struct acpi_processor *pr)
1143 {
1144         unsigned int i;
1145         unsigned int working = 0;
1146
1147         pr->power.timer_broadcast_on_state = INT_MAX;
1148
1149         for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
1150                 struct acpi_processor_cx *cx = &pr->power.states[i];
1151
1152                 switch (cx->type) {
1153                 case ACPI_STATE_C1:
1154                         cx->valid = 1;
1155                         break;
1156
1157                 case ACPI_STATE_C2:
1158                         acpi_processor_power_verify_c2(cx);
1159                         if (cx->valid)
1160                                 acpi_timer_check_state(i, pr, cx);
1161                         break;
1162
1163                 case ACPI_STATE_C3:
1164                         acpi_processor_power_verify_c3(pr, cx);
1165                         if (cx->valid)
1166                                 acpi_timer_check_state(i, pr, cx);
1167                         break;
1168                 }
1169
1170                 if (cx->valid)
1171                         working++;
1172         }
1173
1174         acpi_propagate_timer_broadcast(pr);
1175
1176         return (working);
1177 }
1178
1179 static int acpi_processor_get_power_info(struct acpi_processor *pr)
1180 {
1181         unsigned int i;
1182         int result;
1183
1184
1185         /* NOTE: the idle thread may not be running while calling
1186          * this function */
1187
1188         /* Zero initialize all the C-states info. */
1189         memset(pr->power.states, 0, sizeof(pr->power.states));
1190
1191         result = acpi_processor_get_power_info_cst(pr);
1192         if (result == -ENODEV)
1193                 result = acpi_processor_get_power_info_fadt(pr);
1194
1195         if (result)
1196                 return result;
1197
1198         acpi_processor_get_power_info_default(pr);
1199
1200         pr->power.count = acpi_processor_power_verify(pr);
1201
1202 #ifndef CONFIG_CPU_IDLE
1203         /*
1204          * Set Default Policy
1205          * ------------------
1206          * Now that we know which states are supported, set the default
1207          * policy.  Note that this policy can be changed dynamically
1208          * (e.g. encourage deeper sleeps to conserve battery life when
1209          * not on AC).
1210          */
1211         result = acpi_processor_set_power_policy(pr);
1212         if (result)
1213                 return result;
1214 #endif
1215
1216         /*
1217          * if one state of type C2 or C3 is available, mark this
1218          * CPU as being "idle manageable"
1219          */
1220         for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
1221                 if (pr->power.states[i].valid) {
1222                         pr->power.count = i;
1223                         if (pr->power.states[i].type >= ACPI_STATE_C2)
1224                                 pr->flags.power = 1;
1225                 }
1226         }
1227
1228         return 0;
1229 }
1230
1231 static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
1232 {
1233         struct acpi_processor *pr = seq->private;
1234         unsigned int i;
1235
1236
1237         if (!pr)
1238                 goto end;
1239
1240         seq_printf(seq, "active state:            C%zd\n"
1241                    "max_cstate:              C%d\n"
1242                    "bus master activity:     %08x\n"
1243                    "maximum allowed latency: %d usec\n",
1244                    pr->power.state ? pr->power.state - pr->power.states : 0,
1245                    max_cstate, (unsigned)pr->power.bm_activity,
1246                    pm_qos_requirement(PM_QOS_CPU_DMA_LATENCY));
1247
1248         seq_puts(seq, "states:\n");
1249
1250         for (i = 1; i <= pr->power.count; i++) {
1251                 seq_printf(seq, "   %cC%d:                  ",
1252                            (&pr->power.states[i] ==
1253                             pr->power.state ? '*' : ' '), i);
1254
1255                 if (!pr->power.states[i].valid) {
1256                         seq_puts(seq, "<not supported>\n");
1257                         continue;
1258                 }
1259
1260                 switch (pr->power.states[i].type) {
1261                 case ACPI_STATE_C1:
1262                         seq_printf(seq, "type[C1] ");
1263                         break;
1264                 case ACPI_STATE_C2:
1265                         seq_printf(seq, "type[C2] ");
1266                         break;
1267                 case ACPI_STATE_C3:
1268                         seq_printf(seq, "type[C3] ");
1269                         break;
1270                 default:
1271                         seq_printf(seq, "type[--] ");
1272                         break;
1273                 }
1274
1275                 if (pr->power.states[i].promotion.state)
1276                         seq_printf(seq, "promotion[C%zd] ",
1277                                    (pr->power.states[i].promotion.state -
1278                                     pr->power.states));
1279                 else
1280                         seq_puts(seq, "promotion[--] ");
1281
1282                 if (pr->power.states[i].demotion.state)
1283                         seq_printf(seq, "demotion[C%zd] ",
1284                                    (pr->power.states[i].demotion.state -
1285                                     pr->power.states));
1286                 else
1287                         seq_puts(seq, "demotion[--] ");
1288
1289                 seq_printf(seq, "latency[%03d] usage[%08d] duration[%020llu]\n",
1290                            pr->power.states[i].latency,
1291                            pr->power.states[i].usage,
1292                            (unsigned long long)pr->power.states[i].time);
1293         }
1294
1295       end:
1296         return 0;
1297 }
1298
1299 static int acpi_processor_power_open_fs(struct inode *inode, struct file *file)
1300 {
1301         return single_open(file, acpi_processor_power_seq_show,
1302                            PDE(inode)->data);
1303 }
1304
1305 static const struct file_operations acpi_processor_power_fops = {
1306         .owner = THIS_MODULE,
1307         .open = acpi_processor_power_open_fs,
1308         .read = seq_read,
1309         .llseek = seq_lseek,
1310         .release = single_release,
1311 };
1312
1313 #ifndef CONFIG_CPU_IDLE
1314
1315 int acpi_processor_cst_has_changed(struct acpi_processor *pr)
1316 {
1317         int result = 0;
1318
1319         if (boot_option_idle_override)
1320                 return 0;
1321
1322         if (!pr)
1323                 return -EINVAL;
1324
1325         if (nocst) {
1326                 return -ENODEV;
1327         }
1328
1329         if (!pr->flags.power_setup_done)
1330                 return -ENODEV;
1331
1332         /* Fall back to the default idle loop */
1333         pm_idle = pm_idle_save;
1334         synchronize_sched();    /* Relies on interrupts forcing exit from idle. */
1335
1336         pr->flags.power = 0;
1337         result = acpi_processor_get_power_info(pr);
1338         if ((pr->flags.power == 1) && (pr->flags.power_setup_done))
1339                 pm_idle = acpi_processor_idle;
1340
1341         return result;
1342 }
1343
1344 #ifdef CONFIG_SMP
1345 static void smp_callback(void *v)
1346 {
1347         /* we already woke the CPU up, nothing more to do */
1348 }
1349
1350 /*
1351  * This function gets called when a part of the kernel has a new latency
1352  * requirement.  This means we need to get all processors out of their C-state,
1353  * and then recalculate a new suitable C-state. Just do a cross-cpu IPI; that
1354  * wakes them all right up.
1355  */
1356 static int acpi_processor_latency_notify(struct notifier_block *b,
1357                 unsigned long l, void *v)
1358 {
1359         smp_call_function(smp_callback, NULL, 1);
1360         return NOTIFY_OK;
1361 }
1362
1363 static struct notifier_block acpi_processor_latency_notifier = {
1364         .notifier_call = acpi_processor_latency_notify,
1365 };
1366
1367 #endif
1368
1369 #else /* CONFIG_CPU_IDLE */
1370
1371 /**
1372  * acpi_idle_bm_check - checks if bus master activity was detected
1373  */
1374 static int acpi_idle_bm_check(void)
1375 {
1376         u32 bm_status = 0;
1377
1378         acpi_get_register(ACPI_BITREG_BUS_MASTER_STATUS, &bm_status);
1379         if (bm_status)
1380                 acpi_set_register(ACPI_BITREG_BUS_MASTER_STATUS, 1);
1381         /*
1382          * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect
1383          * the true state of bus mastering activity; forcing us to
1384          * manually check the BMIDEA bit of each IDE channel.
1385          */
1386         else if (errata.piix4.bmisx) {
1387                 if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01)
1388                     || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01))
1389                         bm_status = 1;
1390         }
1391         return bm_status;
1392 }
1393
1394 /**
1395  * acpi_idle_update_bm_rld - updates the BM_RLD bit depending on target state
1396  * @pr: the processor
1397  * @target: the new target state
1398  */
1399 static inline void acpi_idle_update_bm_rld(struct acpi_processor *pr,
1400                                            struct acpi_processor_cx *target)
1401 {
1402         if (pr->flags.bm_rld_set && target->type != ACPI_STATE_C3) {
1403                 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 0);
1404                 pr->flags.bm_rld_set = 0;
1405         }
1406
1407         if (!pr->flags.bm_rld_set && target->type == ACPI_STATE_C3) {
1408                 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 1);
1409                 pr->flags.bm_rld_set = 1;
1410         }
1411 }
1412
1413 /**
1414  * acpi_idle_do_entry - a helper function that does C2 and C3 type entry
1415  * @cx: cstate data
1416  *
1417  * Caller disables interrupt before call and enables interrupt after return.
1418  */
1419 static inline void acpi_idle_do_entry(struct acpi_processor_cx *cx)
1420 {
1421         if (cx->entry_method == ACPI_CSTATE_FFH) {
1422                 /* Call into architectural FFH based C-state */
1423                 acpi_processor_ffh_cstate_enter(cx);
1424         } else if (cx->entry_method == ACPI_CSTATE_HALT) {
1425                 acpi_safe_halt();
1426         } else {
1427                 int unused;
1428                 /* IO port based C-state */
1429                 inb(cx->address);
1430                 /* Dummy wait op - must do something useless after P_LVL2 read
1431                    because chipsets cannot guarantee that STPCLK# signal
1432                    gets asserted in time to freeze execution properly. */
1433                 unused = inl(acpi_gbl_FADT.xpm_timer_block.address);
1434         }
1435 }
1436
1437 /**
1438  * acpi_idle_enter_c1 - enters an ACPI C1 state-type
1439  * @dev: the target CPU
1440  * @state: the state data
1441  *
1442  * This is equivalent to the HALT instruction.
1443  */
1444 static int acpi_idle_enter_c1(struct cpuidle_device *dev,
1445                               struct cpuidle_state *state)
1446 {
1447         u32 t1, t2;
1448         struct acpi_processor *pr;
1449         struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
1450
1451         pr = __get_cpu_var(processors);
1452
1453         if (unlikely(!pr))
1454                 return 0;
1455
1456         local_irq_disable();
1457
1458         /* Do not access any ACPI IO ports in suspend path */
1459         if (acpi_idle_suspend) {
1460                 acpi_safe_halt();
1461                 local_irq_enable();
1462                 return 0;
1463         }
1464
1465         if (pr->flags.bm_check)
1466                 acpi_idle_update_bm_rld(pr, cx);
1467
1468         t1 = inl(acpi_gbl_FADT.xpm_timer_block.address);
1469         acpi_idle_do_entry(cx);
1470         t2 = inl(acpi_gbl_FADT.xpm_timer_block.address);
1471
1472         local_irq_enable();
1473         cx->usage++;
1474
1475         return ticks_elapsed_in_us(t1, t2);
1476 }
1477
1478 /**
1479  * acpi_idle_enter_simple - enters an ACPI state without BM handling
1480  * @dev: the target CPU
1481  * @state: the state data
1482  */
1483 static int acpi_idle_enter_simple(struct cpuidle_device *dev,
1484                                   struct cpuidle_state *state)
1485 {
1486         struct acpi_processor *pr;
1487         struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
1488         u32 t1, t2;
1489         int sleep_ticks = 0;
1490
1491         pr = __get_cpu_var(processors);
1492
1493         if (unlikely(!pr))
1494                 return 0;
1495
1496         if (acpi_idle_suspend)
1497                 return(acpi_idle_enter_c1(dev, state));
1498
1499         local_irq_disable();
1500         current_thread_info()->status &= ~TS_POLLING;
1501         /*
1502          * TS_POLLING-cleared state must be visible before we test
1503          * NEED_RESCHED:
1504          */
1505         smp_mb();
1506
1507         if (unlikely(need_resched())) {
1508                 current_thread_info()->status |= TS_POLLING;
1509                 local_irq_enable();
1510                 return 0;
1511         }
1512
1513         /*
1514          * Must be done before busmaster disable as we might need to
1515          * access HPET !
1516          */
1517         acpi_state_timer_broadcast(pr, cx, 1);
1518
1519         if (pr->flags.bm_check)
1520                 acpi_idle_update_bm_rld(pr, cx);
1521
1522         if (cx->type == ACPI_STATE_C3)
1523                 ACPI_FLUSH_CPU_CACHE();
1524
1525         t1 = inl(acpi_gbl_FADT.xpm_timer_block.address);
1526         /* Tell the scheduler that we are going deep-idle: */
1527         sched_clock_idle_sleep_event();
1528         acpi_idle_do_entry(cx);
1529         t2 = inl(acpi_gbl_FADT.xpm_timer_block.address);
1530
1531 #if defined (CONFIG_GENERIC_TIME) && defined (CONFIG_X86)
1532         /* TSC could halt in idle, so notify users */
1533         if (tsc_halts_in_c(cx->type))
1534                 mark_tsc_unstable("TSC halts in idle");;
1535 #endif
1536         sleep_ticks = ticks_elapsed(t1, t2);
1537
1538         /* Tell the scheduler how much we idled: */
1539         sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS);
1540
1541         local_irq_enable();
1542         current_thread_info()->status |= TS_POLLING;
1543
1544         cx->usage++;
1545
1546         acpi_state_timer_broadcast(pr, cx, 0);
1547         cx->time += sleep_ticks;
1548         return ticks_elapsed_in_us(t1, t2);
1549 }
1550
1551 static int c3_cpu_count;
1552 static DEFINE_SPINLOCK(c3_lock);
1553
1554 /**
1555  * acpi_idle_enter_bm - enters C3 with proper BM handling
1556  * @dev: the target CPU
1557  * @state: the state data
1558  *
1559  * If BM is detected, the deepest non-C3 idle state is entered instead.
1560  */
1561 static int acpi_idle_enter_bm(struct cpuidle_device *dev,
1562                               struct cpuidle_state *state)
1563 {
1564         struct acpi_processor *pr;
1565         struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
1566         u32 t1, t2;
1567         int sleep_ticks = 0;
1568
1569         pr = __get_cpu_var(processors);
1570
1571         if (unlikely(!pr))
1572                 return 0;
1573
1574         if (acpi_idle_suspend)
1575                 return(acpi_idle_enter_c1(dev, state));
1576
1577         if (acpi_idle_bm_check()) {
1578                 if (dev->safe_state) {
1579                         return dev->safe_state->enter(dev, dev->safe_state);
1580                 } else {
1581                         local_irq_disable();
1582                         acpi_safe_halt();
1583                         local_irq_enable();
1584                         return 0;
1585                 }
1586         }
1587
1588         local_irq_disable();
1589         current_thread_info()->status &= ~TS_POLLING;
1590         /*
1591          * TS_POLLING-cleared state must be visible before we test
1592          * NEED_RESCHED:
1593          */
1594         smp_mb();
1595
1596         if (unlikely(need_resched())) {
1597                 current_thread_info()->status |= TS_POLLING;
1598                 local_irq_enable();
1599                 return 0;
1600         }
1601
1602         acpi_unlazy_tlb(smp_processor_id());
1603
1604         /* Tell the scheduler that we are going deep-idle: */
1605         sched_clock_idle_sleep_event();
1606         /*
1607          * Must be done before busmaster disable as we might need to
1608          * access HPET !
1609          */
1610         acpi_state_timer_broadcast(pr, cx, 1);
1611
1612         acpi_idle_update_bm_rld(pr, cx);
1613
1614         /*
1615          * disable bus master
1616          * bm_check implies we need ARB_DIS
1617          * !bm_check implies we need cache flush
1618          * bm_control implies whether we can do ARB_DIS
1619          *
1620          * That leaves a case where bm_check is set and bm_control is
1621          * not set. In that case we cannot do much, we enter C3
1622          * without doing anything.
1623          */
1624         if (pr->flags.bm_check && pr->flags.bm_control) {
1625                 spin_lock(&c3_lock);
1626                 c3_cpu_count++;
1627                 /* Disable bus master arbitration when all CPUs are in C3 */
1628                 if (c3_cpu_count == num_online_cpus())
1629                         acpi_set_register(ACPI_BITREG_ARB_DISABLE, 1);
1630                 spin_unlock(&c3_lock);
1631         } else if (!pr->flags.bm_check) {
1632                 ACPI_FLUSH_CPU_CACHE();
1633         }
1634
1635         t1 = inl(acpi_gbl_FADT.xpm_timer_block.address);
1636         acpi_idle_do_entry(cx);
1637         t2 = inl(acpi_gbl_FADT.xpm_timer_block.address);
1638
1639         /* Re-enable bus master arbitration */
1640         if (pr->flags.bm_check && pr->flags.bm_control) {
1641                 spin_lock(&c3_lock);
1642                 acpi_set_register(ACPI_BITREG_ARB_DISABLE, 0);
1643                 c3_cpu_count--;
1644                 spin_unlock(&c3_lock);
1645         }
1646
1647 #if defined (CONFIG_GENERIC_TIME) && defined (CONFIG_X86)
1648         /* TSC could halt in idle, so notify users */
1649         if (tsc_halts_in_c(ACPI_STATE_C3))
1650                 mark_tsc_unstable("TSC halts in idle");
1651 #endif
1652         sleep_ticks = ticks_elapsed(t1, t2);
1653         /* Tell the scheduler how much we idled: */
1654         sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS);
1655
1656         local_irq_enable();
1657         current_thread_info()->status |= TS_POLLING;
1658
1659         cx->usage++;
1660
1661         acpi_state_timer_broadcast(pr, cx, 0);
1662         cx->time += sleep_ticks;
1663         return ticks_elapsed_in_us(t1, t2);
1664 }
1665
1666 struct cpuidle_driver acpi_idle_driver = {
1667         .name =         "acpi_idle",
1668         .owner =        THIS_MODULE,
1669 };
1670
1671 /**
1672  * acpi_processor_setup_cpuidle - prepares and configures CPUIDLE
1673  * @pr: the ACPI processor
1674  */
1675 static int acpi_processor_setup_cpuidle(struct acpi_processor *pr)
1676 {
1677         int i, count = CPUIDLE_DRIVER_STATE_START;
1678         struct acpi_processor_cx *cx;
1679         struct cpuidle_state *state;
1680         struct cpuidle_device *dev = &pr->power.dev;
1681
1682         if (!pr->flags.power_setup_done)
1683                 return -EINVAL;
1684
1685         if (pr->flags.power == 0) {
1686                 return -EINVAL;
1687         }
1688
1689         dev->cpu = pr->id;
1690         for (i = 0; i < CPUIDLE_STATE_MAX; i++) {
1691                 dev->states[i].name[0] = '\0';
1692                 dev->states[i].desc[0] = '\0';
1693         }
1694
1695         for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
1696                 cx = &pr->power.states[i];
1697                 state = &dev->states[count];
1698
1699                 if (!cx->valid)
1700                         continue;
1701
1702 #ifdef CONFIG_HOTPLUG_CPU
1703                 if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) &&
1704                     !pr->flags.has_cst &&
1705                     !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
1706                         continue;
1707 #endif
1708                 cpuidle_set_statedata(state, cx);
1709
1710                 snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i);
1711                 strncpy(state->desc, cx->desc, CPUIDLE_DESC_LEN);
1712                 state->exit_latency = cx->latency;
1713                 state->target_residency = cx->latency * latency_factor;
1714                 state->power_usage = cx->power;
1715
1716                 state->flags = 0;
1717                 switch (cx->type) {
1718                         case ACPI_STATE_C1:
1719                         state->flags |= CPUIDLE_FLAG_SHALLOW;
1720                         if (cx->entry_method == ACPI_CSTATE_FFH)
1721                                 state->flags |= CPUIDLE_FLAG_TIME_VALID;
1722
1723                         state->enter = acpi_idle_enter_c1;
1724                         dev->safe_state = state;
1725                         break;
1726
1727                         case ACPI_STATE_C2:
1728                         state->flags |= CPUIDLE_FLAG_BALANCED;
1729                         state->flags |= CPUIDLE_FLAG_TIME_VALID;
1730                         state->enter = acpi_idle_enter_simple;
1731                         dev->safe_state = state;
1732                         break;
1733
1734                         case ACPI_STATE_C3:
1735                         state->flags |= CPUIDLE_FLAG_DEEP;
1736                         state->flags |= CPUIDLE_FLAG_TIME_VALID;
1737                         state->flags |= CPUIDLE_FLAG_CHECK_BM;
1738                         state->enter = pr->flags.bm_check ?
1739                                         acpi_idle_enter_bm :
1740                                         acpi_idle_enter_simple;
1741                         break;
1742                 }
1743
1744                 count++;
1745                 if (count == CPUIDLE_STATE_MAX)
1746                         break;
1747         }
1748
1749         dev->state_count = count;
1750
1751         if (!count)
1752                 return -EINVAL;
1753
1754         return 0;
1755 }
1756
1757 int acpi_processor_cst_has_changed(struct acpi_processor *pr)
1758 {
1759         int ret = 0;
1760
1761         if (boot_option_idle_override)
1762                 return 0;
1763
1764         if (!pr)
1765                 return -EINVAL;
1766
1767         if (nocst) {
1768                 return -ENODEV;
1769         }
1770
1771         if (!pr->flags.power_setup_done)
1772                 return -ENODEV;
1773
1774         cpuidle_pause_and_lock();
1775         cpuidle_disable_device(&pr->power.dev);
1776         acpi_processor_get_power_info(pr);
1777         if (pr->flags.power) {
1778                 acpi_processor_setup_cpuidle(pr);
1779                 ret = cpuidle_enable_device(&pr->power.dev);
1780         }
1781         cpuidle_resume_and_unlock();
1782
1783         return ret;
1784 }
1785
1786 #endif /* CONFIG_CPU_IDLE */
1787
1788 int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
1789                               struct acpi_device *device)
1790 {
1791         acpi_status status = 0;
1792         static int first_run;
1793         struct proc_dir_entry *entry = NULL;
1794         unsigned int i;
1795
1796         if (boot_option_idle_override)
1797                 return 0;
1798
1799         if (!first_run) {
1800                 if (idle_halt) {
1801                         /*
1802                          * When the boot option of "idle=halt" is added, halt
1803                          * is used for CPU IDLE.
1804                          * In such case C2/C3 is meaningless. So the max_cstate
1805                          * is set to one.
1806                          */
1807                         max_cstate = 1;
1808                 }
1809                 dmi_check_system(processor_power_dmi_table);
1810                 max_cstate = acpi_processor_cstate_check(max_cstate);
1811                 if (max_cstate < ACPI_C_STATES_MAX)
1812                         printk(KERN_NOTICE
1813                                "ACPI: processor limited to max C-state %d\n",
1814                                max_cstate);
1815                 first_run++;
1816 #if !defined(CONFIG_CPU_IDLE) && defined(CONFIG_SMP)
1817                 pm_qos_add_notifier(PM_QOS_CPU_DMA_LATENCY,
1818                                 &acpi_processor_latency_notifier);
1819 #endif
1820         }
1821
1822         if (!pr)
1823                 return -EINVAL;
1824
1825         if (acpi_gbl_FADT.cst_control && !nocst) {
1826                 status =
1827                     acpi_os_write_port(acpi_gbl_FADT.smi_command, acpi_gbl_FADT.cst_control, 8);
1828                 if (ACPI_FAILURE(status)) {
1829                         ACPI_EXCEPTION((AE_INFO, status,
1830                                         "Notifying BIOS of _CST ability failed"));
1831                 }
1832         }
1833
1834         acpi_processor_get_power_info(pr);
1835         pr->flags.power_setup_done = 1;
1836
1837         /*
1838          * Install the idle handler if processor power management is supported.
1839          * Note that we use previously set idle handler will be used on
1840          * platforms that only support C1.
1841          */
1842         if (pr->flags.power) {
1843 #ifdef CONFIG_CPU_IDLE
1844                 acpi_processor_setup_cpuidle(pr);
1845                 if (cpuidle_register_device(&pr->power.dev))
1846                         return -EIO;
1847 #endif
1848
1849                 printk(KERN_INFO PREFIX "CPU%d (power states:", pr->id);
1850                 for (i = 1; i <= pr->power.count; i++)
1851                         if (pr->power.states[i].valid)
1852                                 printk(" C%d[C%d]", i,
1853                                        pr->power.states[i].type);
1854                 printk(")\n");
1855
1856 #ifndef CONFIG_CPU_IDLE
1857                 if (pr->id == 0) {
1858                         pm_idle_save = pm_idle;
1859                         pm_idle = acpi_processor_idle;
1860                 }
1861 #endif
1862         }
1863
1864         /* 'power' [R] */
1865         entry = proc_create_data(ACPI_PROCESSOR_FILE_POWER,
1866                                  S_IRUGO, acpi_device_dir(device),
1867                                  &acpi_processor_power_fops,
1868                                  acpi_driver_data(device));
1869         if (!entry)
1870                 return -EIO;
1871         return 0;
1872 }
1873
1874 int acpi_processor_power_exit(struct acpi_processor *pr,
1875                               struct acpi_device *device)
1876 {
1877         if (boot_option_idle_override)
1878                 return 0;
1879
1880 #ifdef CONFIG_CPU_IDLE
1881         cpuidle_unregister_device(&pr->power.dev);
1882 #endif
1883         pr->flags.power_setup_done = 0;
1884
1885         if (acpi_device_dir(device))
1886                 remove_proc_entry(ACPI_PROCESSOR_FILE_POWER,
1887                                   acpi_device_dir(device));
1888
1889 #ifndef CONFIG_CPU_IDLE
1890
1891         /* Unregister the idle handler when processor #0 is removed. */
1892         if (pr->id == 0) {
1893                 pm_idle = pm_idle_save;
1894
1895                 /*
1896                  * We are about to unload the current idle thread pm callback
1897                  * (pm_idle), Wait for all processors to update cached/local
1898                  * copies of pm_idle before proceeding.
1899                  */
1900                 cpu_idle_wait();
1901 #ifdef CONFIG_SMP
1902                 pm_qos_remove_notifier(PM_QOS_CPU_DMA_LATENCY,
1903                                 &acpi_processor_latency_notifier);
1904 #endif
1905         }
1906 #endif
1907
1908         return 0;
1909 }