161db4acfb91de2d26ddbde096688de93322f93c
[linux-2.6.git] / 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 }