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