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