- make the state a pointer inside struct acpi_processor_cx_policy, - make acpi_cstate_limit aware of c-state types instead of numbers, as the latter mean (almost) nothing - make the policy decisions of demotion and promotion independent of the assumption "one state per type" Signed-off-by: Dominik Brodowski drivers/acpi/processor_idle.c | 137 +++++++++++++++++++++--------------------- include/acpi/processor.h | 4 - 2 files changed, 74 insertions(+), 67 deletions(-) diff -ruN linux-original/drivers/acpi/processor_idle.c linux/drivers/acpi/processor_idle.c --- linux-original/drivers/acpi/processor_idle.c 2004-11-27 20:26:27.000000000 +0100 +++ linux/drivers/acpi/processor_idle.c 2004-11-27 20:37:01.776120856 +0100 @@ -95,15 +95,14 @@ static void acpi_processor_power_activate ( struct acpi_processor *pr, - int state) + struct acpi_processor_cx *new) { - struct acpi_processor_cx *old, *new; + struct acpi_processor_cx *old; - if (!pr) + if (!pr || !new) return; old = pr->power.state; - new = &pr->power.states[state]; if (old) old->promotion.count = 0; @@ -139,7 +138,7 @@ { struct acpi_processor *pr = NULL; struct acpi_processor_cx *cx = NULL; - int next_state = 0; + struct acpi_processor_cx *next_state = NULL; int sleep_ticks = 0; u32 t1, t2 = 0; @@ -270,7 +269,7 @@ return; } - next_state = pr->power.state - pr->power.states; + next_state = pr->power.state; /* * Promotion? @@ -280,7 +279,7 @@ * mastering activity may prevent promotions. * Do not promote above acpi_cstate_limit. */ - if (cx->promotion.state && (cx->promotion.state <= acpi_cstate_limit)) { + if (cx->promotion.state && (cx->promotion.state->type <= acpi_cstate_limit)) { if (sleep_ticks > cx->promotion.threshold.ticks) { cx->promotion.count++; cx->demotion.count = 0; @@ -331,7 +330,7 @@ * If we're going to start using a new Cx state we must clean up * from the previous and prepare to use the new. */ - if (&pr->power.states[next_state] != pr->power.state) + if (next_state != pr->power.state) acpi_processor_power_activate(pr, next_state); return; @@ -350,7 +349,16 @@ acpi_processor_set_power_policy ( struct acpi_processor *pr) { - ACPI_FUNCTION_TRACE("acpi_processor_set_power_policy"); + unsigned int i; + unsigned int state_is_set = 0; + struct acpi_processor_cx *lower = NULL; + struct acpi_processor_cx *higher = NULL; + struct acpi_processor_cx *cx; + + ACPI_FUNCTION_TRACE("acpi_processor_set_power_policy"); + + if (!pr) + return_VALUE(-EINVAL); /* * This function sets the default Cx state policy (OS idle handler). @@ -361,67 +369,62 @@ * customizable and can be altered dynamically. */ - if (!pr) - return_VALUE(-EINVAL); + /* startup state */ + for (i=1; i < ACPI_PROCESSOR_MAX_POWER; i++) { + cx = &pr->power.states[i]; + if (!cx->valid) + continue; - /* - * C0/C1 - * ----- - */ - pr->power.state = &pr->power.states[ACPI_STATE_C1]; + if (!state_is_set) + pr->power.state = cx; + state_is_set++; + break; + } - /* - * C1/C2 - * ----- - * Set the default C1 promotion and C2 demotion policies, where we - * promote from C1 to C2 after several (10) successive C1 transitions, - * as we cannot (currently) measure the time spent in C1. Demote from - * C2 to C1 anytime we experience a 'short' (time spent in C2 is less - * than the C2 transtion latency). Note the simplifying assumption - * that the 'cost' of a transition is amortized when we sleep for at - * least as long as the transition's latency (thus the total transition - * time is two times the latency). - * - * TBD: Measure C1 sleep times by instrumenting the core IRQ handler. - * TBD: Demote to default C-State after long periods of activity. - * TBD: Investigate policy's use of CPU utilization -vs- sleep duration. - */ - if (pr->power.states[ACPI_STATE_C2].valid) { - pr->power.states[ACPI_STATE_C1].promotion.threshold.count = 10; - pr->power.states[ACPI_STATE_C1].promotion.threshold.ticks = - pr->power.states[ACPI_STATE_C2].latency_ticks; - pr->power.states[ACPI_STATE_C1].promotion.state = ACPI_STATE_C2; - - pr->power.states[ACPI_STATE_C2].demotion.threshold.count = 1; - pr->power.states[ACPI_STATE_C2].demotion.threshold.ticks = - pr->power.states[ACPI_STATE_C2].latency_ticks; - pr->power.states[ACPI_STATE_C2].demotion.state = ACPI_STATE_C1; + if (!state_is_set) + return_VALUE(-ENODEV); + + /* demotion */ + for (i=1; i < ACPI_PROCESSOR_MAX_POWER; i++) { + cx = &pr->power.states[i]; + if (!cx->valid) + continue; + + if (lower) { + cx->demotion.state = lower; + cx->demotion.threshold.ticks = cx->latency_ticks; + cx->demotion.threshold.count = 1; + if (cx->type == ACPI_STATE_C3) + cx->demotion.threshold.bm = 0x0F; + } + + /* from C3 we always demote to C2, even if there are multiple + * states of type C3 available. */ + if (cx->type < ACPI_STATE_C3) + lower = cx; } - /* - * C2/C3 - * ----- - * Set default C2 promotion and C3 demotion policies, where we promote - * from C2 to C3 after several (4) cycles of no bus mastering activity - * while maintaining sleep time criteria. Demote immediately on a - * short or whenever bus mastering activity occurs. - */ - if ((pr->power.states[ACPI_STATE_C2].valid) && - (pr->power.states[ACPI_STATE_C3].valid)) { - pr->power.states[ACPI_STATE_C2].promotion.threshold.count = 4; - pr->power.states[ACPI_STATE_C2].promotion.threshold.ticks = - pr->power.states[ACPI_STATE_C3].latency_ticks; - pr->power.states[ACPI_STATE_C2].promotion.threshold.bm = 0x0F; - pr->power.states[ACPI_STATE_C2].promotion.state = ACPI_STATE_C3; - - pr->power.states[ACPI_STATE_C3].demotion.threshold.count = 1; - pr->power.states[ACPI_STATE_C3].demotion.threshold.ticks = - pr->power.states[ACPI_STATE_C3].latency_ticks; - pr->power.states[ACPI_STATE_C3].demotion.threshold.bm = 0x0F; - pr->power.states[ACPI_STATE_C3].demotion.state = ACPI_STATE_C2; + /* promotion */ + for (i = (ACPI_PROCESSOR_MAX_POWER - 1); i > 0; i--) { + cx = &pr->power.states[i]; + if (!cx->valid) + continue; + + if (higher) { + cx->promotion.state = higher; + cx->demotion.threshold.ticks = cx->latency_ticks; + if (cx->type >= ACPI_STATE_C2) + cx->promotion.threshold.count = 4; + else + cx->promotion.threshold.count = 10; + if (higher->type == ACPI_STATE_C3) + cx->demotion.threshold.bm = 0x0F; + } + + higher = cx; } - return_VALUE(0); + return_VALUE(0); } static int acpi_processor_get_power_info_fadt (struct acpi_processor *pr) @@ -682,13 +685,15 @@ if (pr->power.states[i].promotion.state) seq_printf(seq, "promotion[%d] ", - pr->power.states[i].promotion.state); + (pr->power.states[i].promotion.state - + pr->power.states)); else seq_puts(seq, "promotion[-] "); if (pr->power.states[i].demotion.state) seq_printf(seq, "demotion[%d] ", - pr->power.states[i].demotion.state); + (pr->power.states[i].demotion.state - + pr->power.states)); else seq_puts(seq, "demotion[-] "); diff -ruN linux-original/include/acpi/processor.h linux/include/acpi/processor.h --- linux-original/include/acpi/processor.h 2004-11-27 20:26:27.000000000 +0100 +++ linux/include/acpi/processor.h 2004-11-27 20:30:33.000000000 +0100 @@ -16,9 +16,11 @@ /* Power Management */ +struct acpi_processor_cx; + struct acpi_processor_cx_policy { u32 count; - int state; + struct acpi_processor_cx *state; struct { u32 time; u32 ticks;