Merge branch 'for-rmk/samsung6' of git://git.fluff.org/bjdooks/linux into devel-stable
[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, 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/irqflags.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 PREFIX "ACPI: "
64
65 #define ACPI_PROCESSOR_CLASS            "processor"
66 #define _COMPONENT              ACPI_PROCESSOR_COMPONENT
67 ACPI_MODULE_NAME("processor_idle");
68 #define ACPI_PROCESSOR_FILE_POWER       "power"
69 #define PM_TIMER_TICK_NS                (1000000000ULL/PM_TIMER_FREQUENCY)
70 #define C2_OVERHEAD                     1       /* 1us */
71 #define C3_OVERHEAD                     1       /* 1us */
72 #define PM_TIMER_TICKS_TO_US(p)         (((p) * 1000)/(PM_TIMER_FREQUENCY/1000))
73
74 static unsigned int max_cstate __read_mostly = ACPI_PROCESSOR_MAX_POWER;
75 module_param(max_cstate, uint, 0000);
76 static unsigned int nocst __read_mostly;
77 module_param(nocst, uint, 0000);
78
79 static unsigned int latency_factor __read_mostly = 2;
80 module_param(latency_factor, uint, 0644);
81
82 static s64 us_to_pm_timer_ticks(s64 t)
83 {
84         return div64_u64(t * PM_TIMER_FREQUENCY, 1000000);
85 }
86 /*
87  * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3.
88  * For now disable this. Probably a bug somewhere else.
89  *
90  * To skip this limit, boot/load with a large max_cstate limit.
91  */
92 static int set_max_cstate(const struct dmi_system_id *id)
93 {
94         if (max_cstate > ACPI_PROCESSOR_MAX_POWER)
95                 return 0;
96
97         printk(KERN_NOTICE PREFIX "%s detected - limiting to C%ld max_cstate."
98                " Override with \"processor.max_cstate=%d\"\n", id->ident,
99                (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1);
100
101         max_cstate = (long)id->driver_data;
102
103         return 0;
104 }
105
106 /* Actually this shouldn't be __cpuinitdata, would be better to fix the
107    callers to only run once -AK */
108 static struct dmi_system_id __cpuinitdata processor_power_dmi_table[] = {
109         { set_max_cstate, "Clevo 5600D", {
110           DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
111           DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")},
112          (void *)2},
113         { set_max_cstate, "Pavilion zv5000", {
114           DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
115           DMI_MATCH(DMI_PRODUCT_NAME,"Pavilion zv5000 (DS502A#ABA)")},
116          (void *)1},
117         { set_max_cstate, "Asus L8400B", {
118           DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
119           DMI_MATCH(DMI_PRODUCT_NAME,"L8400B series Notebook PC")},
120          (void *)1},
121         {},
122 };
123
124
125 /*
126  * Callers should disable interrupts before the call and enable
127  * interrupts after return.
128  */
129 static void acpi_safe_halt(void)
130 {
131         current_thread_info()->status &= ~TS_POLLING;
132         /*
133          * TS_POLLING-cleared state must be visible before we
134          * test NEED_RESCHED:
135          */
136         smp_mb();
137         if (!need_resched()) {
138                 safe_halt();
139                 local_irq_disable();
140         }
141         current_thread_info()->status |= TS_POLLING;
142 }
143
144 #ifdef ARCH_APICTIMER_STOPS_ON_C3
145
146 /*
147  * Some BIOS implementations switch to C3 in the published C2 state.
148  * This seems to be a common problem on AMD boxen, but other vendors
149  * are affected too. We pick the most conservative approach: we assume
150  * that the local APIC stops in both C2 and C3.
151  */
152 static void lapic_timer_check_state(int state, struct acpi_processor *pr,
153                                    struct acpi_processor_cx *cx)
154 {
155         struct acpi_processor_power *pwr = &pr->power;
156         u8 type = local_apic_timer_c2_ok ? ACPI_STATE_C3 : ACPI_STATE_C2;
157
158         if (cpu_has(&cpu_data(pr->id), X86_FEATURE_ARAT))
159                 return;
160
161         if (boot_cpu_has(X86_FEATURE_AMDC1E))
162                 type = ACPI_STATE_C1;
163
164         /*
165          * Check, if one of the previous states already marked the lapic
166          * unstable
167          */
168         if (pwr->timer_broadcast_on_state < state)
169                 return;
170
171         if (cx->type >= type)
172                 pr->power.timer_broadcast_on_state = state;
173 }
174
175 static void __lapic_timer_propagate_broadcast(void *arg)
176 {
177         struct acpi_processor *pr = (struct acpi_processor *) arg;
178         unsigned long reason;
179
180         reason = pr->power.timer_broadcast_on_state < INT_MAX ?
181                 CLOCK_EVT_NOTIFY_BROADCAST_ON : CLOCK_EVT_NOTIFY_BROADCAST_OFF;
182
183         clockevents_notify(reason, &pr->id);
184 }
185
186 static void lapic_timer_propagate_broadcast(struct acpi_processor *pr)
187 {
188         smp_call_function_single(pr->id, __lapic_timer_propagate_broadcast,
189                                  (void *)pr, 1);
190 }
191
192 /* Power(C) State timer broadcast control */
193 static void lapic_timer_state_broadcast(struct acpi_processor *pr,
194                                        struct acpi_processor_cx *cx,
195                                        int broadcast)
196 {
197         int state = cx - pr->power.states;
198
199         if (state >= pr->power.timer_broadcast_on_state) {
200                 unsigned long reason;
201
202                 reason = broadcast ?  CLOCK_EVT_NOTIFY_BROADCAST_ENTER :
203                         CLOCK_EVT_NOTIFY_BROADCAST_EXIT;
204                 clockevents_notify(reason, &pr->id);
205         }
206 }
207
208 #else
209
210 static void lapic_timer_check_state(int state, struct acpi_processor *pr,
211                                    struct acpi_processor_cx *cstate) { }
212 static void lapic_timer_propagate_broadcast(struct acpi_processor *pr) { }
213 static void lapic_timer_state_broadcast(struct acpi_processor *pr,
214                                        struct acpi_processor_cx *cx,
215                                        int broadcast)
216 {
217 }
218
219 #endif
220
221 /*
222  * Suspend / resume control
223  */
224 static int acpi_idle_suspend;
225 static u32 saved_bm_rld;
226
227 static void acpi_idle_bm_rld_save(void)
228 {
229         acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &saved_bm_rld);
230 }
231 static void acpi_idle_bm_rld_restore(void)
232 {
233         u32 resumed_bm_rld;
234
235         acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &resumed_bm_rld);
236
237         if (resumed_bm_rld != saved_bm_rld)
238                 acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld);
239 }
240
241 int acpi_processor_suspend(struct acpi_device * device, pm_message_t state)
242 {
243         if (acpi_idle_suspend == 1)
244                 return 0;
245
246         acpi_idle_bm_rld_save();
247         acpi_idle_suspend = 1;
248         return 0;
249 }
250
251 int acpi_processor_resume(struct acpi_device * device)
252 {
253         if (acpi_idle_suspend == 0)
254                 return 0;
255
256         acpi_idle_bm_rld_restore();
257         acpi_idle_suspend = 0;
258         return 0;
259 }
260
261 #if defined (CONFIG_GENERIC_TIME) && defined (CONFIG_X86)
262 static void tsc_check_state(int state)
263 {
264         switch (boot_cpu_data.x86_vendor) {
265         case X86_VENDOR_AMD:
266         case X86_VENDOR_INTEL:
267                 /*
268                  * AMD Fam10h TSC will tick in all
269                  * C/P/S0/S1 states when this bit is set.
270                  */
271                 if (boot_cpu_has(X86_FEATURE_NONSTOP_TSC))
272                         return;
273
274                 /*FALL THROUGH*/
275         default:
276                 /* TSC could halt in idle, so notify users */
277                 if (state > ACPI_STATE_C1)
278                         mark_tsc_unstable("TSC halts in idle");
279         }
280 }
281 #else
282 static void tsc_check_state(int state) { return; }
283 #endif
284
285 static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
286 {
287
288         if (!pr)
289                 return -EINVAL;
290
291         if (!pr->pblk)
292                 return -ENODEV;
293
294         /* if info is obtained from pblk/fadt, type equals state */
295         pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2;
296         pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3;
297
298 #ifndef CONFIG_HOTPLUG_CPU
299         /*
300          * Check for P_LVL2_UP flag before entering C2 and above on
301          * an SMP system.
302          */
303         if ((num_online_cpus() > 1) &&
304             !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
305                 return -ENODEV;
306 #endif
307
308         /* determine C2 and C3 address from pblk */
309         pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4;
310         pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5;
311
312         /* determine latencies from FADT */
313         pr->power.states[ACPI_STATE_C2].latency = acpi_gbl_FADT.C2latency;
314         pr->power.states[ACPI_STATE_C3].latency = acpi_gbl_FADT.C3latency;
315
316         /*
317          * FADT specified C2 latency must be less than or equal to
318          * 100 microseconds.
319          */
320         if (acpi_gbl_FADT.C2latency > ACPI_PROCESSOR_MAX_C2_LATENCY) {
321                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
322                         "C2 latency too large [%d]\n", acpi_gbl_FADT.C2latency));
323                 /* invalidate C2 */
324                 pr->power.states[ACPI_STATE_C2].address = 0;
325         }
326
327         /*
328          * FADT supplied C3 latency must be less than or equal to
329          * 1000 microseconds.
330          */
331         if (acpi_gbl_FADT.C3latency > ACPI_PROCESSOR_MAX_C3_LATENCY) {
332                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
333                         "C3 latency too large [%d]\n", acpi_gbl_FADT.C3latency));
334                 /* invalidate C3 */
335                 pr->power.states[ACPI_STATE_C3].address = 0;
336         }
337
338         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
339                           "lvl2[0x%08x] lvl3[0x%08x]\n",
340                           pr->power.states[ACPI_STATE_C2].address,
341                           pr->power.states[ACPI_STATE_C3].address));
342
343         return 0;
344 }
345
346 static int acpi_processor_get_power_info_default(struct acpi_processor *pr)
347 {
348         if (!pr->power.states[ACPI_STATE_C1].valid) {
349                 /* set the first C-State to C1 */
350                 /* all processors need to support C1 */
351                 pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1;
352                 pr->power.states[ACPI_STATE_C1].valid = 1;
353                 pr->power.states[ACPI_STATE_C1].entry_method = ACPI_CSTATE_HALT;
354         }
355         /* the C0 state only exists as a filler in our array */
356         pr->power.states[ACPI_STATE_C0].valid = 1;
357         return 0;
358 }
359
360 static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
361 {
362         acpi_status status = 0;
363         acpi_integer count;
364         int current_count;
365         int i;
366         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
367         union acpi_object *cst;
368
369
370         if (nocst)
371                 return -ENODEV;
372
373         current_count = 0;
374
375         status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer);
376         if (ACPI_FAILURE(status)) {
377                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _CST, giving up\n"));
378                 return -ENODEV;
379         }
380
381         cst = buffer.pointer;
382
383         /* There must be at least 2 elements */
384         if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) {
385                 printk(KERN_ERR PREFIX "not enough elements in _CST\n");
386                 status = -EFAULT;
387                 goto end;
388         }
389
390         count = cst->package.elements[0].integer.value;
391
392         /* Validate number of power states. */
393         if (count < 1 || count != cst->package.count - 1) {
394                 printk(KERN_ERR PREFIX "count given by _CST is not valid\n");
395                 status = -EFAULT;
396                 goto end;
397         }
398
399         /* Tell driver that at least _CST is supported. */
400         pr->flags.has_cst = 1;
401
402         for (i = 1; i <= count; i++) {
403                 union acpi_object *element;
404                 union acpi_object *obj;
405                 struct acpi_power_register *reg;
406                 struct acpi_processor_cx cx;
407
408                 memset(&cx, 0, sizeof(cx));
409
410                 element = &(cst->package.elements[i]);
411                 if (element->type != ACPI_TYPE_PACKAGE)
412                         continue;
413
414                 if (element->package.count != 4)
415                         continue;
416
417                 obj = &(element->package.elements[0]);
418
419                 if (obj->type != ACPI_TYPE_BUFFER)
420                         continue;
421
422                 reg = (struct acpi_power_register *)obj->buffer.pointer;
423
424                 if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO &&
425                     (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE))
426                         continue;
427
428                 /* There should be an easy way to extract an integer... */
429                 obj = &(element->package.elements[1]);
430                 if (obj->type != ACPI_TYPE_INTEGER)
431                         continue;
432
433                 cx.type = obj->integer.value;
434                 /*
435                  * Some buggy BIOSes won't list C1 in _CST -
436                  * Let acpi_processor_get_power_info_default() handle them later
437                  */
438                 if (i == 1 && cx.type != ACPI_STATE_C1)
439                         current_count++;
440
441                 cx.address = reg->address;
442                 cx.index = current_count + 1;
443
444                 cx.entry_method = ACPI_CSTATE_SYSTEMIO;
445                 if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
446                         if (acpi_processor_ffh_cstate_probe
447                                         (pr->id, &cx, reg) == 0) {
448                                 cx.entry_method = ACPI_CSTATE_FFH;
449                         } else if (cx.type == ACPI_STATE_C1) {
450                                 /*
451                                  * C1 is a special case where FIXED_HARDWARE
452                                  * can be handled in non-MWAIT way as well.
453                                  * In that case, save this _CST entry info.
454                                  * Otherwise, ignore this info and continue.
455                                  */
456                                 cx.entry_method = ACPI_CSTATE_HALT;
457                                 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
458                         } else {
459                                 continue;
460                         }
461                         if (cx.type == ACPI_STATE_C1 &&
462                                         (idle_halt || idle_nomwait)) {
463                                 /*
464                                  * In most cases the C1 space_id obtained from
465                                  * _CST object is FIXED_HARDWARE access mode.
466                                  * But when the option of idle=halt is added,
467                                  * the entry_method type should be changed from
468                                  * CSTATE_FFH to CSTATE_HALT.
469                                  * When the option of idle=nomwait is added,
470                                  * the C1 entry_method type should be
471                                  * CSTATE_HALT.
472                                  */
473                                 cx.entry_method = ACPI_CSTATE_HALT;
474                                 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
475                         }
476                 } else {
477                         snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI IOPORT 0x%x",
478                                  cx.address);
479                 }
480
481                 if (cx.type == ACPI_STATE_C1) {
482                         cx.valid = 1;
483                 }
484
485                 obj = &(element->package.elements[2]);
486                 if (obj->type != ACPI_TYPE_INTEGER)
487                         continue;
488
489                 cx.latency = obj->integer.value;
490
491                 obj = &(element->package.elements[3]);
492                 if (obj->type != ACPI_TYPE_INTEGER)
493                         continue;
494
495                 cx.power = obj->integer.value;
496
497                 current_count++;
498                 memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx));
499
500                 /*
501                  * We support total ACPI_PROCESSOR_MAX_POWER - 1
502                  * (From 1 through ACPI_PROCESSOR_MAX_POWER - 1)
503                  */
504                 if (current_count >= (ACPI_PROCESSOR_MAX_POWER - 1)) {
505                         printk(KERN_WARNING
506                                "Limiting number of power states to max (%d)\n",
507                                ACPI_PROCESSOR_MAX_POWER);
508                         printk(KERN_WARNING
509                                "Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n");
510                         break;
511                 }
512         }
513
514         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n",
515                           current_count));
516
517         /* Validate number of power states discovered */
518         if (current_count < 2)
519                 status = -EFAULT;
520
521       end:
522         kfree(buffer.pointer);
523
524         return status;
525 }
526
527 static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
528                                            struct acpi_processor_cx *cx)
529 {
530         static int bm_check_flag = -1;
531         static int bm_control_flag = -1;
532
533
534         if (!cx->address)
535                 return;
536
537         /*
538          * PIIX4 Erratum #18: We don't support C3 when Type-F (fast)
539          * DMA transfers are used by any ISA device to avoid livelock.
540          * Note that we could disable Type-F DMA (as recommended by
541          * the erratum), but this is known to disrupt certain ISA
542          * devices thus we take the conservative approach.
543          */
544         else if (errata.piix4.fdma) {
545                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
546                                   "C3 not supported on PIIX4 with Type-F DMA\n"));
547                 return;
548         }
549
550         /* All the logic here assumes flags.bm_check is same across all CPUs */
551         if (bm_check_flag == -1) {
552                 /* Determine whether bm_check is needed based on CPU  */
553                 acpi_processor_power_init_bm_check(&(pr->flags), pr->id);
554                 bm_check_flag = pr->flags.bm_check;
555                 bm_control_flag = pr->flags.bm_control;
556         } else {
557                 pr->flags.bm_check = bm_check_flag;
558                 pr->flags.bm_control = bm_control_flag;
559         }
560
561         if (pr->flags.bm_check) {
562                 if (!pr->flags.bm_control) {
563                         if (pr->flags.has_cst != 1) {
564                                 /* bus mastering control is necessary */
565                                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
566                                         "C3 support requires BM control\n"));
567                                 return;
568                         } else {
569                                 /* Here we enter C3 without bus mastering */
570                                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
571                                         "C3 support without BM control\n"));
572                         }
573                 }
574         } else {
575                 /*
576                  * WBINVD should be set in fadt, for C3 state to be
577                  * supported on when bm_check is not required.
578                  */
579                 if (!(acpi_gbl_FADT.flags & ACPI_FADT_WBINVD)) {
580                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
581                                           "Cache invalidation should work properly"
582                                           " for C3 to be enabled on SMP systems\n"));
583                         return;
584                 }
585         }
586
587         /*
588          * Otherwise we've met all of our C3 requirements.
589          * Normalize the C3 latency to expidite policy.  Enable
590          * checking of bus mastering status (bm_check) so we can
591          * use this in our C3 policy
592          */
593         cx->valid = 1;
594
595         cx->latency_ticks = cx->latency;
596         /*
597          * On older chipsets, BM_RLD needs to be set
598          * in order for Bus Master activity to wake the
599          * system from C3.  Newer chipsets handle DMA
600          * during C3 automatically and BM_RLD is a NOP.
601          * In either case, the proper way to
602          * handle BM_RLD is to set it and leave it set.
603          */
604         acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, 1);
605
606         return;
607 }
608
609 static int acpi_processor_power_verify(struct acpi_processor *pr)
610 {
611         unsigned int i;
612         unsigned int working = 0;
613
614         pr->power.timer_broadcast_on_state = INT_MAX;
615
616         for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
617                 struct acpi_processor_cx *cx = &pr->power.states[i];
618
619                 switch (cx->type) {
620                 case ACPI_STATE_C1:
621                         cx->valid = 1;
622                         break;
623
624                 case ACPI_STATE_C2:
625                         if (!cx->address)
626                                 break;
627                         cx->valid = 1; 
628                         cx->latency_ticks = cx->latency; /* Normalize latency */
629                         break;
630
631                 case ACPI_STATE_C3:
632                         acpi_processor_power_verify_c3(pr, cx);
633                         break;
634                 }
635                 if (!cx->valid)
636                         continue;
637
638                 lapic_timer_check_state(i, pr, cx);
639                 tsc_check_state(cx->type);
640                 working++;
641         }
642
643         lapic_timer_propagate_broadcast(pr);
644
645         return (working);
646 }
647
648 static int acpi_processor_get_power_info(struct acpi_processor *pr)
649 {
650         unsigned int i;
651         int result;
652
653
654         /* NOTE: the idle thread may not be running while calling
655          * this function */
656
657         /* Zero initialize all the C-states info. */
658         memset(pr->power.states, 0, sizeof(pr->power.states));
659
660         result = acpi_processor_get_power_info_cst(pr);
661         if (result == -ENODEV)
662                 result = acpi_processor_get_power_info_fadt(pr);
663
664         if (result)
665                 return result;
666
667         acpi_processor_get_power_info_default(pr);
668
669         pr->power.count = acpi_processor_power_verify(pr);
670
671         /*
672          * if one state of type C2 or C3 is available, mark this
673          * CPU as being "idle manageable"
674          */
675         for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
676                 if (pr->power.states[i].valid) {
677                         pr->power.count = i;
678                         if (pr->power.states[i].type >= ACPI_STATE_C2)
679                                 pr->flags.power = 1;
680                 }
681         }
682
683         return 0;
684 }
685
686 #ifdef CONFIG_ACPI_PROCFS
687 static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
688 {
689         struct acpi_processor *pr = seq->private;
690         unsigned int i;
691
692
693         if (!pr)
694                 goto end;
695
696         seq_printf(seq, "active state:            C%zd\n"
697                    "max_cstate:              C%d\n"
698                    "maximum allowed latency: %d usec\n",
699                    pr->power.state ? pr->power.state - pr->power.states : 0,
700                    max_cstate, pm_qos_requirement(PM_QOS_CPU_DMA_LATENCY));
701
702         seq_puts(seq, "states:\n");
703
704         for (i = 1; i <= pr->power.count; i++) {
705                 seq_printf(seq, "   %cC%d:                  ",
706                            (&pr->power.states[i] ==
707                             pr->power.state ? '*' : ' '), i);
708
709                 if (!pr->power.states[i].valid) {
710                         seq_puts(seq, "<not supported>\n");
711                         continue;
712                 }
713
714                 switch (pr->power.states[i].type) {
715                 case ACPI_STATE_C1:
716                         seq_printf(seq, "type[C1] ");
717                         break;
718                 case ACPI_STATE_C2:
719                         seq_printf(seq, "type[C2] ");
720                         break;
721                 case ACPI_STATE_C3:
722                         seq_printf(seq, "type[C3] ");
723                         break;
724                 default:
725                         seq_printf(seq, "type[--] ");
726                         break;
727                 }
728
729                 if (pr->power.states[i].promotion.state)
730                         seq_printf(seq, "promotion[C%zd] ",
731                                    (pr->power.states[i].promotion.state -
732                                     pr->power.states));
733                 else
734                         seq_puts(seq, "promotion[--] ");
735
736                 if (pr->power.states[i].demotion.state)
737                         seq_printf(seq, "demotion[C%zd] ",
738                                    (pr->power.states[i].demotion.state -
739                                     pr->power.states));
740                 else
741                         seq_puts(seq, "demotion[--] ");
742
743                 seq_printf(seq, "latency[%03d] usage[%08d] duration[%020llu]\n",
744                            pr->power.states[i].latency,
745                            pr->power.states[i].usage,
746                            (unsigned long long)pr->power.states[i].time);
747         }
748
749       end:
750         return 0;
751 }
752
753 static int acpi_processor_power_open_fs(struct inode *inode, struct file *file)
754 {
755         return single_open(file, acpi_processor_power_seq_show,
756                            PDE(inode)->data);
757 }
758
759 static const struct file_operations acpi_processor_power_fops = {
760         .owner = THIS_MODULE,
761         .open = acpi_processor_power_open_fs,
762         .read = seq_read,
763         .llseek = seq_lseek,
764         .release = single_release,
765 };
766 #endif
767
768 /**
769  * acpi_idle_bm_check - checks if bus master activity was detected
770  */
771 static int acpi_idle_bm_check(void)
772 {
773         u32 bm_status = 0;
774
775         acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, &bm_status);
776         if (bm_status)
777                 acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, 1);
778         /*
779          * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect
780          * the true state of bus mastering activity; forcing us to
781          * manually check the BMIDEA bit of each IDE channel.
782          */
783         else if (errata.piix4.bmisx) {
784                 if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01)
785                     || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01))
786                         bm_status = 1;
787         }
788         return bm_status;
789 }
790
791 /**
792  * acpi_idle_do_entry - a helper function that does C2 and C3 type entry
793  * @cx: cstate data
794  *
795  * Caller disables interrupt before call and enables interrupt after return.
796  */
797 static inline void acpi_idle_do_entry(struct acpi_processor_cx *cx)
798 {
799         /* Don't trace irqs off for idle */
800         stop_critical_timings();
801         if (cx->entry_method == ACPI_CSTATE_FFH) {
802                 /* Call into architectural FFH based C-state */
803                 acpi_processor_ffh_cstate_enter(cx);
804         } else if (cx->entry_method == ACPI_CSTATE_HALT) {
805                 acpi_safe_halt();
806         } else {
807                 int unused;
808                 /* IO port based C-state */
809                 inb(cx->address);
810                 /* Dummy wait op - must do something useless after P_LVL2 read
811                    because chipsets cannot guarantee that STPCLK# signal
812                    gets asserted in time to freeze execution properly. */
813                 unused = inl(acpi_gbl_FADT.xpm_timer_block.address);
814         }
815         start_critical_timings();
816 }
817
818 /**
819  * acpi_idle_enter_c1 - enters an ACPI C1 state-type
820  * @dev: the target CPU
821  * @state: the state data
822  *
823  * This is equivalent to the HALT instruction.
824  */
825 static int acpi_idle_enter_c1(struct cpuidle_device *dev,
826                               struct cpuidle_state *state)
827 {
828         ktime_t  kt1, kt2;
829         s64 idle_time;
830         struct acpi_processor *pr;
831         struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
832
833         pr = __get_cpu_var(processors);
834
835         if (unlikely(!pr))
836                 return 0;
837
838         local_irq_disable();
839
840         /* Do not access any ACPI IO ports in suspend path */
841         if (acpi_idle_suspend) {
842                 local_irq_enable();
843                 cpu_relax();
844                 return 0;
845         }
846
847         lapic_timer_state_broadcast(pr, cx, 1);
848         kt1 = ktime_get_real();
849         acpi_idle_do_entry(cx);
850         kt2 = ktime_get_real();
851         idle_time =  ktime_to_us(ktime_sub(kt2, kt1));
852
853         local_irq_enable();
854         cx->usage++;
855         lapic_timer_state_broadcast(pr, cx, 0);
856
857         return idle_time;
858 }
859
860 /**
861  * acpi_idle_enter_simple - enters an ACPI state without BM handling
862  * @dev: the target CPU
863  * @state: the state data
864  */
865 static int acpi_idle_enter_simple(struct cpuidle_device *dev,
866                                   struct cpuidle_state *state)
867 {
868         struct acpi_processor *pr;
869         struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
870         ktime_t  kt1, kt2;
871         s64 idle_time;
872         s64 sleep_ticks = 0;
873
874         pr = __get_cpu_var(processors);
875
876         if (unlikely(!pr))
877                 return 0;
878
879         if (acpi_idle_suspend)
880                 return(acpi_idle_enter_c1(dev, state));
881
882         local_irq_disable();
883         current_thread_info()->status &= ~TS_POLLING;
884         /*
885          * TS_POLLING-cleared state must be visible before we test
886          * NEED_RESCHED:
887          */
888         smp_mb();
889
890         if (unlikely(need_resched())) {
891                 current_thread_info()->status |= TS_POLLING;
892                 local_irq_enable();
893                 return 0;
894         }
895
896         /*
897          * Must be done before busmaster disable as we might need to
898          * access HPET !
899          */
900         lapic_timer_state_broadcast(pr, cx, 1);
901
902         if (cx->type == ACPI_STATE_C3)
903                 ACPI_FLUSH_CPU_CACHE();
904
905         kt1 = ktime_get_real();
906         /* Tell the scheduler that we are going deep-idle: */
907         sched_clock_idle_sleep_event();
908         acpi_idle_do_entry(cx);
909         kt2 = ktime_get_real();
910         idle_time =  ktime_to_us(ktime_sub(kt2, kt1));
911
912         sleep_ticks = us_to_pm_timer_ticks(idle_time);
913
914         /* Tell the scheduler how much we idled: */
915         sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS);
916
917         local_irq_enable();
918         current_thread_info()->status |= TS_POLLING;
919
920         cx->usage++;
921
922         lapic_timer_state_broadcast(pr, cx, 0);
923         cx->time += sleep_ticks;
924         return idle_time;
925 }
926
927 static int c3_cpu_count;
928 static DEFINE_SPINLOCK(c3_lock);
929
930 /**
931  * acpi_idle_enter_bm - enters C3 with proper BM handling
932  * @dev: the target CPU
933  * @state: the state data
934  *
935  * If BM is detected, the deepest non-C3 idle state is entered instead.
936  */
937 static int acpi_idle_enter_bm(struct cpuidle_device *dev,
938                               struct cpuidle_state *state)
939 {
940         struct acpi_processor *pr;
941         struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
942         ktime_t  kt1, kt2;
943         s64 idle_time;
944         s64 sleep_ticks = 0;
945
946
947         pr = __get_cpu_var(processors);
948
949         if (unlikely(!pr))
950                 return 0;
951
952         if (acpi_idle_suspend)
953                 return(acpi_idle_enter_c1(dev, state));
954
955         if (acpi_idle_bm_check()) {
956                 if (dev->safe_state) {
957                         dev->last_state = dev->safe_state;
958                         return dev->safe_state->enter(dev, dev->safe_state);
959                 } else {
960                         local_irq_disable();
961                         acpi_safe_halt();
962                         local_irq_enable();
963                         return 0;
964                 }
965         }
966
967         local_irq_disable();
968         current_thread_info()->status &= ~TS_POLLING;
969         /*
970          * TS_POLLING-cleared state must be visible before we test
971          * NEED_RESCHED:
972          */
973         smp_mb();
974
975         if (unlikely(need_resched())) {
976                 current_thread_info()->status |= TS_POLLING;
977                 local_irq_enable();
978                 return 0;
979         }
980
981         acpi_unlazy_tlb(smp_processor_id());
982
983         /* Tell the scheduler that we are going deep-idle: */
984         sched_clock_idle_sleep_event();
985         /*
986          * Must be done before busmaster disable as we might need to
987          * access HPET !
988          */
989         lapic_timer_state_broadcast(pr, cx, 1);
990
991         kt1 = ktime_get_real();
992         /*
993          * disable bus master
994          * bm_check implies we need ARB_DIS
995          * !bm_check implies we need cache flush
996          * bm_control implies whether we can do ARB_DIS
997          *
998          * That leaves a case where bm_check is set and bm_control is
999          * not set. In that case we cannot do much, we enter C3
1000          * without doing anything.
1001          */
1002         if (pr->flags.bm_check && pr->flags.bm_control) {
1003                 spin_lock(&c3_lock);
1004                 c3_cpu_count++;
1005                 /* Disable bus master arbitration when all CPUs are in C3 */
1006                 if (c3_cpu_count == num_online_cpus())
1007                         acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 1);
1008                 spin_unlock(&c3_lock);
1009         } else if (!pr->flags.bm_check) {
1010                 ACPI_FLUSH_CPU_CACHE();
1011         }
1012
1013         acpi_idle_do_entry(cx);
1014
1015         /* Re-enable bus master arbitration */
1016         if (pr->flags.bm_check && pr->flags.bm_control) {
1017                 spin_lock(&c3_lock);
1018                 acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 0);
1019                 c3_cpu_count--;
1020                 spin_unlock(&c3_lock);
1021         }
1022         kt2 = ktime_get_real();
1023         idle_time =  ktime_to_us(ktime_sub(kt2, kt1));
1024
1025         sleep_ticks = us_to_pm_timer_ticks(idle_time);
1026         /* Tell the scheduler how much we idled: */
1027         sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS);
1028
1029         local_irq_enable();
1030         current_thread_info()->status |= TS_POLLING;
1031
1032         cx->usage++;
1033
1034         lapic_timer_state_broadcast(pr, cx, 0);
1035         cx->time += sleep_ticks;
1036         return idle_time;
1037 }
1038
1039 struct cpuidle_driver acpi_idle_driver = {
1040         .name =         "acpi_idle",
1041         .owner =        THIS_MODULE,
1042 };
1043
1044 /**
1045  * acpi_processor_setup_cpuidle - prepares and configures CPUIDLE
1046  * @pr: the ACPI processor
1047  */
1048 static int acpi_processor_setup_cpuidle(struct acpi_processor *pr)
1049 {
1050         int i, count = CPUIDLE_DRIVER_STATE_START;
1051         struct acpi_processor_cx *cx;
1052         struct cpuidle_state *state;
1053         struct cpuidle_device *dev = &pr->power.dev;
1054
1055         if (!pr->flags.power_setup_done)
1056                 return -EINVAL;
1057
1058         if (pr->flags.power == 0) {
1059                 return -EINVAL;
1060         }
1061
1062         dev->cpu = pr->id;
1063         for (i = 0; i < CPUIDLE_STATE_MAX; i++) {
1064                 dev->states[i].name[0] = '\0';
1065                 dev->states[i].desc[0] = '\0';
1066         }
1067
1068         if (max_cstate == 0)
1069                 max_cstate = 1;
1070
1071         for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
1072                 cx = &pr->power.states[i];
1073                 state = &dev->states[count];
1074
1075                 if (!cx->valid)
1076                         continue;
1077
1078 #ifdef CONFIG_HOTPLUG_CPU
1079                 if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) &&
1080                     !pr->flags.has_cst &&
1081                     !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
1082                         continue;
1083 #endif
1084                 cpuidle_set_statedata(state, cx);
1085
1086                 snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i);
1087                 strncpy(state->desc, cx->desc, CPUIDLE_DESC_LEN);
1088                 state->exit_latency = cx->latency;
1089                 state->target_residency = cx->latency * latency_factor;
1090                 state->power_usage = cx->power;
1091
1092                 state->flags = 0;
1093                 switch (cx->type) {
1094                         case ACPI_STATE_C1:
1095                         state->flags |= CPUIDLE_FLAG_SHALLOW;
1096                         if (cx->entry_method == ACPI_CSTATE_FFH)
1097                                 state->flags |= CPUIDLE_FLAG_TIME_VALID;
1098
1099                         state->enter = acpi_idle_enter_c1;
1100                         dev->safe_state = state;
1101                         break;
1102
1103                         case ACPI_STATE_C2:
1104                         state->flags |= CPUIDLE_FLAG_BALANCED;
1105                         state->flags |= CPUIDLE_FLAG_TIME_VALID;
1106                         state->enter = acpi_idle_enter_simple;
1107                         dev->safe_state = state;
1108                         break;
1109
1110                         case ACPI_STATE_C3:
1111                         state->flags |= CPUIDLE_FLAG_DEEP;
1112                         state->flags |= CPUIDLE_FLAG_TIME_VALID;
1113                         state->flags |= CPUIDLE_FLAG_CHECK_BM;
1114                         state->enter = pr->flags.bm_check ?
1115                                         acpi_idle_enter_bm :
1116                                         acpi_idle_enter_simple;
1117                         break;
1118                 }
1119
1120                 count++;
1121                 if (count == CPUIDLE_STATE_MAX)
1122                         break;
1123         }
1124
1125         dev->state_count = count;
1126
1127         if (!count)
1128                 return -EINVAL;
1129
1130         return 0;
1131 }
1132
1133 int acpi_processor_cst_has_changed(struct acpi_processor *pr)
1134 {
1135         int ret = 0;
1136
1137         if (boot_option_idle_override)
1138                 return 0;
1139
1140         if (!pr)
1141                 return -EINVAL;
1142
1143         if (nocst) {
1144                 return -ENODEV;
1145         }
1146
1147         if (!pr->flags.power_setup_done)
1148                 return -ENODEV;
1149
1150         cpuidle_pause_and_lock();
1151         cpuidle_disable_device(&pr->power.dev);
1152         acpi_processor_get_power_info(pr);
1153         if (pr->flags.power) {
1154                 acpi_processor_setup_cpuidle(pr);
1155                 ret = cpuidle_enable_device(&pr->power.dev);
1156         }
1157         cpuidle_resume_and_unlock();
1158
1159         return ret;
1160 }
1161
1162 int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
1163                               struct acpi_device *device)
1164 {
1165         acpi_status status = 0;
1166         static int first_run;
1167 #ifdef CONFIG_ACPI_PROCFS
1168         struct proc_dir_entry *entry = NULL;
1169 #endif
1170
1171         if (boot_option_idle_override)
1172                 return 0;
1173
1174         if (!first_run) {
1175                 if (idle_halt) {
1176                         /*
1177                          * When the boot option of "idle=halt" is added, halt
1178                          * is used for CPU IDLE.
1179                          * In such case C2/C3 is meaningless. So the max_cstate
1180                          * is set to one.
1181                          */
1182                         max_cstate = 1;
1183                 }
1184                 dmi_check_system(processor_power_dmi_table);
1185                 max_cstate = acpi_processor_cstate_check(max_cstate);
1186                 if (max_cstate < ACPI_C_STATES_MAX)
1187                         printk(KERN_NOTICE
1188                                "ACPI: processor limited to max C-state %d\n",
1189                                max_cstate);
1190                 first_run++;
1191         }
1192
1193         if (!pr)
1194                 return -EINVAL;
1195
1196         if (acpi_gbl_FADT.cst_control && !nocst) {
1197                 status =
1198                     acpi_os_write_port(acpi_gbl_FADT.smi_command, acpi_gbl_FADT.cst_control, 8);
1199                 if (ACPI_FAILURE(status)) {
1200                         ACPI_EXCEPTION((AE_INFO, status,
1201                                         "Notifying BIOS of _CST ability failed"));
1202                 }
1203         }
1204
1205         acpi_processor_get_power_info(pr);
1206         pr->flags.power_setup_done = 1;
1207
1208         /*
1209          * Install the idle handler if processor power management is supported.
1210          * Note that we use previously set idle handler will be used on
1211          * platforms that only support C1.
1212          */
1213         if (pr->flags.power) {
1214                 acpi_processor_setup_cpuidle(pr);
1215                 if (cpuidle_register_device(&pr->power.dev))
1216                         return -EIO;
1217         }
1218 #ifdef CONFIG_ACPI_PROCFS
1219         /* 'power' [R] */
1220         entry = proc_create_data(ACPI_PROCESSOR_FILE_POWER,
1221                                  S_IRUGO, acpi_device_dir(device),
1222                                  &acpi_processor_power_fops,
1223                                  acpi_driver_data(device));
1224         if (!entry)
1225                 return -EIO;
1226 #endif
1227         return 0;
1228 }
1229
1230 int acpi_processor_power_exit(struct acpi_processor *pr,
1231                               struct acpi_device *device)
1232 {
1233         if (boot_option_idle_override)
1234                 return 0;
1235
1236         cpuidle_unregister_device(&pr->power.dev);
1237         pr->flags.power_setup_done = 0;
1238
1239 #ifdef CONFIG_ACPI_PROCFS
1240         if (acpi_device_dir(device))
1241                 remove_proc_entry(ACPI_PROCESSOR_FILE_POWER,
1242                                   acpi_device_dir(device));
1243 #endif
1244
1245         return 0;
1246 }