/*
* cpu.c - Processor handling
*
* Copyright (C) 2000 Andrew Henroid
* Copyright (C) 2001 Andrew Grover
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/pm.h>
#include <linux/acpi.h>
#include "acpi.h"
#include "driver.h"
#define _COMPONENT OS_DEPENDENT
MODULE_NAME ("cpu")
u32 acpi_c2_exit_latency = ACPI_INFINITE;
u32 acpi_c3_exit_latency = ACPI_INFINITE;
u32 acpi_c2_enter_latency = ACPI_INFINITE;
u32 acpi_c3_enter_latency = ACPI_INFINITE;
u32 acpi_use_idle = TRUE;
u32 acpi_c1_count = 0;
u32 acpi_c2_count = 0;
u32 acpi_c3_count = 0;
static u32 acpi_pblk = ACPI_INVALID;
static int acpi_c2_tested = 0;
static int acpi_c3_tested = 0;
static int acpi_max_c_state = 1;
static int acpi_pm_tmr_len = 24;
#define CPU_POWER_STATES 3
#define MAX_C2_LATENCY 100
#define MAX_C3_LATENCY 1000
#define ACPI_STATE_C1 0
#define ACPI_STATE_C2 1
#define ACPI_STATE_C3 2
/*
* Clear busmaster activity flag
*/
static inline void
acpi_clear_bm_activity(void)
{
acpi_hw_register_bit_access(ACPI_WRITE, ACPI_MTX_LOCK, BM_STS, 1);
}
/*
* Returns 1 if there has been busmaster activity
*/
static inline int
acpi_bm_activity(void)
{
return acpi_hw_register_bit_access(ACPI_READ, ACPI_MTX_LOCK, BM_STS);
}
/*
* Set system to sleep through busmaster requests
*/
static void
acpi_sleep_on_busmaster(void)
{
acpi_hw_register_bit_access (ACPI_WRITE, ACPI_MTX_LOCK, BM_RLD, 1);
}
/*
* Set system to wake on busmaster requests
*/
static void
acpi_wake_on_busmaster(void)
{
acpi_hw_register_bit_access (ACPI_WRITE, ACPI_MTX_LOCK, BM_RLD, 0);
}
u32
acpi_read_pm_timer(void)
{
return acpi_hw_register_read(ACPI_MTX_LOCK, PM_TIMER);
}
/*
* Do a compare, accounting for 24/32bit rollover
*/
static u32
acpi_compare_pm_timers(u32 first, u32 second)
{
if (first < second) {
return (second - first);
} else {
if (acpi_pm_tmr_len == 24)
return (second + (0xFFFFFF - first));
else
return (second + (0xFFFFFFFF - first));
}
}
/*
* Idle loop (uniprocessor only)
*/
static void
acpi_idle(void)
{
static int sleep_level = 1;
FADT_DESCRIPTOR *fadt = &acpi_fadt;
/*
* start from the previous sleep level.
* if not initialized, we goto sleep1
*/
if (sleep_level == 1
|| acpi_max_c_state < 2)
goto sleep1;
if (sleep_level == 2
|| acpi_max_c_state < 3)
goto sleep2;
sleep3:
sleep_level = 3;
if (!acpi_c3_tested) {
DEBUG_PRINT(ACPI_INFO, ("C3 works\n"));
acpi_c3_tested = 1;
}
acpi_wake_on_busmaster();
if (fadt->Xpm2_cnt_blk.address)
goto sleep3_with_arbiter;
for (;;) {
unsigned long time;
unsigned long diff;
__cli();
if (current->need_resched)
goto out;
if (acpi_bm_activity())
goto sleep2;
time = acpi_read_pm_timer();
acpi_c3_count++;
inb(acpi_pblk + ACPI_P_LVL3);
/* Dummy read, force synchronization with the PMU */
acpi_read_pm_timer();
diff = acpi_compare_pm_timers(time, acpi_read_pm_timer());
__sti();
if (diff < acpi_c3_exit_latency)
goto sleep1;
}
sleep3_with_arbiter:
for (;;) {
unsigned long time;
unsigned long diff;
__cli();
if (current->need_resched)
goto out;
if (acpi_bm_activity())
goto sleep2;
time = acpi_read_pm_timer();
/* Disable arbiter, park on CPU */
acpi_hw_register_bit_access(ACPI_WRITE, ACPI_MTX_LOCK, ARB_DIS, 1);
acpi_c3_count++;
inb(acpi_pblk + ACPI_P_LVL3);
/* Dummy read, force synchronization with the PMU */
acpi_read_pm_timer();
diff = acpi_compare_pm_timers(time, acpi_read_pm_timer());
/* Enable arbiter again.. */
acpi_hw_register_bit_access(ACPI_WRITE, ACPI_MTX_LOCK, ARB_DIS, 0);
__sti();
if (diff < acpi_c3_exit_latency)
goto sleep1;
}
sleep2:
sleep_level = 2;
if (!acpi_c2_tested) {
DEBUG_PRINT(ACPI_INFO, ("C2 works\n"));
acpi_c2_tested = 1;
}
acpi_wake_on_busmaster(); /* Required to track BM activity.. */
for (;;) {
unsigned long time;
unsigned long diff;
__cli();
if (current->need_resched)
goto out;
time = acpi_read_pm_timer();
acpi_c2_count++;
inb(acpi_pblk + ACPI_P_LVL2);
/* Dummy read, force synchronization with the PMU */
acpi_read_pm_timer();
diff = acpi_compare_pm_timers(time, acpi_read_pm_timer());
__sti();
if (diff < acpi_c2_exit_latency)
goto sleep1;
if (acpi_bm_activity()) {
acpi_clear_bm_activity();
continue;
}
if (diff > acpi_c3_enter_latency
&& acpi_max_c_state >= 3)
goto sleep3;
}
sleep1:
sleep_level = 1;
acpi_sleep_on_busmaster();
for (;;) {
unsigned long time;
unsigned long diff;
__cli();
if (current->need_resched)
goto out;
time = acpi_read_pm_timer();
acpi_c1_count++;
safe_halt();
diff = acpi_compare_pm_timers(time, acpi_read_pm_timer());
if (diff > acpi_c2_enter_latency
&& acpi_max_c_state >= 2)
goto sleep2;
}
out:
__sti();
}
/*
* Get processor information
*/
static ACPI_STATUS
acpi_found_cpu(ACPI_HANDLE handle, u32 level, void *ctx, void **value)
{
ACPI_OBJECT obj;
ACPI_BUFFER buf;
buf.length = sizeof(obj);
buf.pointer = &obj;
if (!ACPI_SUCCESS(acpi_evaluate_object(handle, NULL, NULL, &buf)))
return AE_OK;
DEBUG_PRINT(ACPI_INFO, ("PBLK %d @ 0x%04x:%d\n",
obj.processor.proc_id,
obj.processor.pblk_address,
obj.processor.pblk_length));
if (acpi_pblk != ACPI_INVALID
|| !obj.processor.pblk_address
|| obj.processor.pblk_length != 6)
return AE_OK;
acpi_pblk = obj.processor.pblk_address;
if (acpi_fadt.plvl2_lat
&& acpi_fadt.plvl2_lat <= MAX_C2_LATENCY) {
acpi_c2_exit_latency
= ACPI_MICROSEC_TO_TMR_TICKS(acpi_fadt.plvl2_lat);
acpi_c2_enter_latency
= ACPI_MICROSEC_TO_TMR_TICKS(acpi_fadt.plvl2_lat * 4);
acpi_max_c_state = 2;
printk(KERN_INFO "ACPI: System firmware supports: C2");
if (acpi_fadt.plvl3_lat
&& acpi_fadt.plvl3_lat <= MAX_C3_LATENCY) {
acpi_c3_exit_latency
= ACPI_MICROSEC_TO_TMR_TICKS(acpi_fadt.plvl3_lat);
acpi_c3_enter_latency
= ACPI_MICROSEC_TO_TMR_TICKS(acpi_fadt.plvl3_lat * 12);
acpi_max_c_state = 3;
printk(" C3");
}
printk("\n");
}
printk(KERN_INFO "ACPI: plvl2lat=%d plvl3lat=%d\n", acpi_fadt.plvl2_lat, acpi_fadt.plvl3_lat);
printk(KERN_INFO "ACPI: C2 enter=%d C2 exit=%d\n", acpi_c2_enter_latency, acpi_c2_exit_latency);
printk(KERN_INFO "ACPI: C3 enter=%d C3 exit=%d\n", acpi_c3_enter_latency, acpi_c3_exit_latency);
return AE_OK;
}
static int
acpi_pm_timer_init(void)
{
FADT_DESCRIPTOR *fadt = &acpi_fadt;
if (fadt->tmr_val_ext) {
acpi_pm_tmr_len = 32;
} else {
acpi_pm_tmr_len = 24;
}
DEBUG_PRINT(ACPI_INFO, ("PM Timer width: %d bits\n", acpi_pm_tmr_len));
return AE_OK;
}
int
acpi_cpu_init(void)
{
acpi_walk_namespace(ACPI_TYPE_PROCESSOR,
ACPI_ROOT_OBJECT,
ACPI_UINT32_MAX,
acpi_found_cpu,
NULL,
NULL);
acpi_pm_timer_init();
if (acpi_use_idle) {
#ifdef CONFIG_SMP
if (smp_num_cpus == 1)
pm_idle = acpi_idle;
#else
pm_idle = acpi_idle;
#endif
printk(KERN_INFO "ACPI: Using ACPI idle\n");
printk(KERN_INFO "ACPI: If experiencing system slowness, try adding \"acpi=no-idle\" to cmdline\n");
}
else {
printk(KERN_INFO "ACPI: Not using ACPI idle\n");
}
return 0;
}
