Viewing file:  sm_osl.c (19.75 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/******************************************************************************
*
* Module Name: sm_osl.c
* $Revision: 16 $
*
*****************************************************************************/
/*
* Copyright (C) 2000, 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/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/proc_fs.h>
#include <linux/pm.h>
#include <asm/uaccess.h>
#include <linux/acpi.h>
#include <asm/io.h>
#include <linux/mc146818rtc.h>
#include <linux/delay.h>
#include <acpi.h>
#include "sm.h"
MODULE_AUTHOR("Andrew Grover");
MODULE_DESCRIPTION("ACPI Component Architecture (CA) - ACPI System Driver");
MODULE_LICENSE("GPL");
#define SM_PROC_INFO "info"
#define SM_PROC_DSDT "dsdt"
extern struct proc_dir_entry *bm_proc_root;
struct proc_dir_entry *sm_proc_root = NULL;
static void (*sm_pm_power_off)(void) = NULL;
static ssize_t sm_osl_read_dsdt(struct file *, char *, size_t, loff_t *);
static struct file_operations proc_dsdt_operations = {
read: sm_osl_read_dsdt,
};
static acpi_status sm_osl_suspend(u32 state);
struct proc_dir_entry *bm_proc_sleep;
struct proc_dir_entry *bm_proc_alarm;
struct proc_dir_entry *bm_proc_gpe;
static int
sm_osl_proc_read_sleep (
char *page,
char **start,
off_t off,
int count,
int *eof,
void *context)
{
SM_CONTEXT *system = (SM_CONTEXT*) context;
char *str = page;
int len;
int i;
if (!system)
goto end;
if (off != 0)
goto end;
for (i = 0; i <= ACPI_S5; i++) {
if (system->states[i])
str += sprintf(str,"S%d ", i);
}
str += sprintf(str, "\n");
end:
len = (str - page);
if (len < (off + count))
*eof = 1;
*start = page + off;
len -= off;
if (len > count)
len = count;
if (len < 0)
len = 0;
return (len);
}
int sm_osl_proc_write_sleep (struct file *file,
const char *buffer,
unsigned long count,
void *data)
{
SM_CONTEXT *system = (SM_CONTEXT*) data;
char str[10];
char *strend;
unsigned long value;
if (count > (sizeof(str) - 1))
return -EINVAL;
if (copy_from_user(str,buffer,count))
return -EFAULT;
str[count] = '\0';
value = simple_strtoul(str,&strend,0);
if (str == strend)
return -EINVAL;
if (value == 0 || value >= ACPI_S5)
return -EINVAL;
/*
* make sure that the sleep state is supported
*/
if (system->states[value] != TRUE)
return -EINVAL;
sm_osl_suspend(value);
return (count);
}
/****************************************************************************
*
* FUNCTION: sm_osl_proc_read_info
*
****************************************************************************/
static int
sm_osl_proc_read_info (
char *page,
char **start,
off_t off,
int count,
int *eof,
void *context)
{
acpi_status status = AE_OK;
SM_CONTEXT *system = NULL;
char *p = page;
int len;
acpi_system_info system_info;
acpi_buffer buffer;
u32 i = 0;
if (!context) {
goto end;
}
system = (SM_CONTEXT*) context;
/* don't get status more than once for a single proc read */
if (off != 0) {
goto end;
}
/*
* Get ACPI CA Information.
*/
buffer.length = sizeof(system_info);
buffer.pointer = &system_info;
status = acpi_get_system_info(&buffer);
if (ACPI_FAILURE(status)) {
p += sprintf(p, "ACPI-CA Version: unknown\n");
}
else {
p += sprintf(p, "ACPI-CA Version: %x\n",
system_info.acpi_ca_version);
}
p += sprintf(p, "Sx States Supported: ");
for (i=0; i<SM_MAX_SYSTEM_STATES; i++) {
if (system->states[i]) {
p += sprintf(p, "S%d ", i);
}
}
p += sprintf(p, "\n");
end:
len = (p - page);
if (len <= off+count) *eof = 1;
*start = page + off;
len -= off;
if (len>count) len = count;
if (len<0) len = 0;
return(len);
}
/****************************************************************************
*
* FUNCTION: sm_osl_read_dsdt
*
****************************************************************************/
static ssize_t
sm_osl_read_dsdt(
struct file *file,
char *buf,
size_t count,
loff_t *ppos)
{
acpi_buffer acpi_buf;
void *data;
size_t size = 0;
acpi_buf.length = 0;
acpi_buf.pointer = NULL;
/* determine what buffer size we will need */
if (acpi_get_table(ACPI_TABLE_DSDT, 1, &acpi_buf) != AE_BUFFER_OVERFLOW) {
return 0;
}
acpi_buf.pointer = kmalloc(acpi_buf.length, GFP_KERNEL);
if (!acpi_buf.pointer) {
return -ENOMEM;
}
/* get the table for real */
if (!ACPI_SUCCESS(acpi_get_table(ACPI_TABLE_DSDT, 1, &acpi_buf))) {
kfree(acpi_buf.pointer);
return 0;
}
if (*ppos < acpi_buf.length) {
data = acpi_buf.pointer + file->f_pos;
size = acpi_buf.length - file->f_pos;
if (size > count)
size = count;
if (copy_to_user(buf, data, size)) {
kfree(acpi_buf.pointer);
return -EFAULT;
}
}
kfree(acpi_buf.pointer);
*ppos += size;
return size;
}
static int
sm_osl_proc_read_alarm (
char *page,
char **start,
off_t off,
int count,
int *eof,
void *context)
{
char *str = page;
int len;
u32 sec,min,hr;
u32 day,mo,yr;
if (off != 0) goto out;
spin_lock(&rtc_lock);
sec = CMOS_READ(RTC_SECONDS_ALARM);
min = CMOS_READ(RTC_MINUTES_ALARM);
hr = CMOS_READ(RTC_HOURS_ALARM);
#if 0
/* if I ever get an FACP with proper values, maybe I'll enable this code */
if (acpi_gbl_FADT->day_alrm)
day = CMOS_READ(acpi_gbl_FADT->day_alrm);
else
day = CMOS_READ(RTC_DAY_OF_MONTH);
if (acpi_gbl_FADT->mon_alrm)
mo = CMOS_READ(acpi_gbl_FADT->mon_alrm);
else
mo = CMOS_READ(RTC_MONTH);;
if (acpi_gbl_FADT->century)
yr = CMOS_READ(acpi_gbl_FADT->century) * 100 + CMOS_READ(RTC_YEAR);
else
yr = CMOS_READ(RTC_YEAR);
#else
day = CMOS_READ(RTC_DAY_OF_MONTH);
mo = CMOS_READ(RTC_MONTH);
yr = CMOS_READ(RTC_YEAR);
#endif
spin_unlock(&rtc_lock);
BCD_TO_BIN(sec);
BCD_TO_BIN(min);
BCD_TO_BIN(hr);
BCD_TO_BIN(day);
BCD_TO_BIN(mo);
BCD_TO_BIN(yr);
str += sprintf(str,"%4.4u-",yr);
str += (mo > 12) ?
sprintf(str,"**-") :
sprintf(str,"%2.2u-",mo);
str += (day > 31) ?
sprintf(str,"** ") :
sprintf(str,"%2.2u ",day);
str += (hr > 23) ?
sprintf(str,"**:") :
sprintf(str,"%2.2u:",hr);
str += (min > 59) ?
sprintf(str,"**:") :
sprintf(str,"%2.2u:",min);
str += (sec > 59) ?
sprintf(str,"**\n") :
sprintf(str,"%2.2u\n",sec);
out:
len = str - page;
if (len < count) *eof = 1;
else if (len > count) len = count;
if (len < 0) len = 0;
*start = page;
return len;
}
static int get_date_field(char **str, u32 *value)
{
char *next,*strend;
int error = -EINVAL;
/* try to find delimeter, only to insert null;
* the end of string won't have one, but is still valid
*/
next = strpbrk(*str,"- :");
if (next) *next++ = '\0';
*value = simple_strtoul(*str,&strend,10);
/* signal success if we got a good digit */
if (strend != *str) error = 0;
if (next) *str = next;
return error;
}
int sm_osl_proc_write_alarm (
struct file *file,
const char *buffer,
unsigned long count,
void *data)
{
char buf[30];
char *str = buf;
u32 sec,min,hr;
u32 day,mo,yr;
int adjust = 0;
unsigned char rtc_control;
int error = -EINVAL;
if (count > sizeof(buf) - 1) return -EINVAL;
if (copy_from_user(str,buffer,count)) return -EFAULT;
str[count] = '\0';
/* check for time adjustment */
if (str[0] == '+') {
str++;
adjust = 1;
}
if ((error = get_date_field(&str,&yr))) goto out;
if ((error = get_date_field(&str,&mo))) goto out;
if ((error = get_date_field(&str,&day))) goto out;
if ((error = get_date_field(&str,&hr))) goto out;
if ((error = get_date_field(&str,&min))) goto out;
if ((error = get_date_field(&str,&sec))) goto out;
if (sec > 59) {
min += 1;
sec -= 60;
}
if (min > 59) {
hr += 1;
min -= 60;
}
if (hr > 23) {
day += 1;
hr -= 24;
}
if (day > 31) {
mo += 1;
day -= 31;
}
if (mo > 12) {
yr += 1;
mo -= 12;
}
spin_lock_irq(&rtc_lock);
rtc_control = CMOS_READ(RTC_CONTROL);
if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
BIN_TO_BCD(yr);
BIN_TO_BCD(mo);
BIN_TO_BCD(day);
BIN_TO_BCD(hr);
BIN_TO_BCD(min);
BIN_TO_BCD(sec);
}
if (adjust) {
yr += CMOS_READ(RTC_YEAR);
mo += CMOS_READ(RTC_MONTH);
day += CMOS_READ(RTC_DAY_OF_MONTH);
hr += CMOS_READ(RTC_HOURS);
min += CMOS_READ(RTC_MINUTES);
sec += CMOS_READ(RTC_SECONDS);
}
spin_unlock_irq(&rtc_lock);
if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
BCD_TO_BIN(yr);
BCD_TO_BIN(mo);
BCD_TO_BIN(day);
BCD_TO_BIN(hr);
BCD_TO_BIN(min);
BCD_TO_BIN(sec);
}
if (sec > 59) {
min++;
sec -= 60;
}
if (min > 59) {
hr++;
min -= 60;
}
if (hr > 23) {
day++;
hr -= 24;
}
if (day > 31) {
mo++;
day -= 31;
}
if (mo > 12) {
yr++;
mo -= 12;
}
if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
BIN_TO_BCD(yr);
BIN_TO_BCD(mo);
BIN_TO_BCD(day);
BIN_TO_BCD(hr);
BIN_TO_BCD(min);
BIN_TO_BCD(sec);
}
spin_lock_irq(&rtc_lock);
/* write the fields the rtc knows about */
CMOS_WRITE(hr,RTC_HOURS_ALARM);
CMOS_WRITE(min,RTC_MINUTES_ALARM);
CMOS_WRITE(sec,RTC_SECONDS_ALARM);
/* If the system supports an enhanced alarm, it will have non-zero
* offsets into the CMOS RAM here.
* Which for some reason are pointing to the RTC area of memory.
*/
#if 0
if (acpi_gbl_FADT->day_alrm) CMOS_WRITE(day,acpi_gbl_FADT->day_alrm);
if (acpi_gbl_FADT->mon_alrm) CMOS_WRITE(mo,acpi_gbl_FADT->mon_alrm);
if (acpi_gbl_FADT->century) CMOS_WRITE(yr / 100,acpi_gbl_FADT->century);
#endif
/* enable the rtc alarm interrupt */
if (!(rtc_control & RTC_AIE)) {
rtc_control |= RTC_AIE;
CMOS_WRITE(rtc_control,RTC_CONTROL);
CMOS_READ(RTC_INTR_FLAGS);
}
/* unlock the lock on the rtc now that we're done with it */
spin_unlock_irq(&rtc_lock);
acpi_hw_register_bit_access(ACPI_WRITE,ACPI_MTX_LOCK, RTC_EN, 1);
file->f_pos += count;
error = 0;
out:
return error ? error : count;
}
static int
sm_osl_proc_read_gpe(
char *page,
char **start,
off_t off,
int count,
int *eof,
void *context)
{
char *str = page;
int size;
int length;
int i;
u32 addr,data;
if (off) goto out;
if (acpi_gbl_FADT->V1_gpe0blk) {
length = acpi_gbl_FADT->gpe0blk_len / 2;
str += sprintf(str,"GPE0: ");
for (i = length; i > 0; i--) {
addr = GPE0_EN_BLOCK | (i - 1);
data = acpi_hw_register_read(ACPI_MTX_LOCK,addr);
str += sprintf(str,"%2.2x ",data);
}
str += sprintf(str,"\n");
str += sprintf(str,"Status: ");
for (i = length; i > 0; i--) {
addr = GPE0_STS_BLOCK | (i - 1);
data = acpi_hw_register_read(ACPI_MTX_LOCK,addr);
str += sprintf(str,"%2.2x ",data);
}
str += sprintf(str,"\n");
}
if (acpi_gbl_FADT->V1_gpe1_blk) {
length = acpi_gbl_FADT->gpe1_blk_len / 2;
str += sprintf(str,"GPE1: ");
for (i = length; i > 0; i--) {
addr = GPE1_EN_BLOCK | (i - 1);
data = acpi_hw_register_read(ACPI_MTX_LOCK,addr);
str += sprintf(str,"%2.2x",data);
}
str += sprintf(str,"\n");
str += sprintf(str,"Status: ");
for (i = length; i > 0; i--) {
addr = GPE1_STS_BLOCK | (i - 1);
data = acpi_hw_register_read(ACPI_MTX_LOCK,addr);
str += sprintf(str,"%2.2x",data);
}
str += sprintf(str,"\n");
}
out:
size = str - page;
if (size < count) *eof = 1;
else if (size > count) size = count;
if (size < 0) size = 0;
*start = page;
return size;
}
static int
sm_osl_proc_write_gpe (
struct file *file,
const char *buffer,
unsigned long count,
void *data)
{
char buf[256];
char *str = buf;
char *next;
int error = -EINVAL;
u32 addr,value = 0;
if (count > sizeof(buf) + 1) return -EINVAL;
if (copy_from_user(str,buffer,count)) return -EFAULT;
str[count] = '\0';
/* set addr to which block to refer to */
if (!strncmp(str,"GPE0 ",5)) addr = GPE0_EN_BLOCK;
else if (!strncmp(str,"GPE1 ",5)) addr = GPE1_EN_BLOCK;
else goto out;
str += 5;
/* set low order bits to index of bit to set */
addr |= simple_strtoul(str,&next,0);
if (next == str) goto out;
if (next) {
str = ++next;
value = simple_strtoul(str,&next,0);
if (next == str) value = 1;
}
value = acpi_hw_register_bit_access(ACPI_WRITE,ACPI_MTX_LOCK,addr,(value ? 1 : 0));
error = 0;
out:
return error ? error : count;
}
/****************************************************************************
*
* FUNCTION: sm_osl_suspend
*
* PARAMETERS: %state: Sleep state to enter. Assumed that caller has filtered
* out bogus values, so it's one of S1, S2, S3 or S4
*
* RETURN: ACPI_STATUS, whether or not we successfully entered and
* exited sleep.
*
* DESCRIPTION:
* This function is the meat of the sleep routine, as far as the ACPI-CA is
* concerned.
*
* See Chapter 9 of the ACPI 2.0 spec for details concerning the methodology here.
*
* It will do the following things:
* - Call arch-specific routines to save the processor and kernel state
* - Call acpi_enter_sleep_state to actually go to sleep
* ....
* When we wake back up, we will:
* - Restore the processor and kernel state
* - Return to the user
*
* By having this routine in here, it hides it from every part of the CA,
* so it can remain OS-independent. The only function that calls this is
* sm_proc_write_sleep, which gets the sleep state to enter from the user.
*
****************************************************************************/
static acpi_status
sm_osl_suspend(u32 state)
{
acpi_status status = AE_ERROR;
unsigned long wakeup_address;
/* get out if state is invalid */
if (state < ACPI_S1 || state > ACPI_S5)
goto acpi_sleep_done;
/* make sure we don't get any suprises */
disable();
/* TODO: save device state and suspend them */
/* save the processor state to memory if going into S2 or S3;
* save it to disk if going into S4.
* Also, set the FWV if going into an STR state
*/
if (state == ACPI_S2 || state == ACPI_S3) {
#ifdef DONT_USE_UNTIL_LOWLEVEL_CODE_EXISTS
wakeup_address = acpi_save_state_mem((unsigned long)&&acpi_sleep_done);
if (!wakeup_address) goto acpi_sleep_done;
acpi_set_firmware_waking_vector(
(ACPI_PHYSICAL_ADDRESS)wakeup_address);
#endif
} else if (state == ACPI_S4)
#ifdef DONT_USE_UNTIL_LOWLEVEL_CODE_EXISTS
if (acpi_save_state_disk((unsigned long)&&acpi_sleep_done))
goto acpi_sleep_done;
#endif
/* set status, since acpi_enter_sleep_state won't return unless something
* goes wrong, or it's just S1.
*/
status = AE_OK;
mdelay(10);
status = acpi_enter_sleep_state(state);
acpi_sleep_done:
/* pause for a bit to allow devices to come back on */
mdelay(10);
/* make sure that the firmware waking vector is reset */
acpi_set_firmware_waking_vector((ACPI_PHYSICAL_ADDRESS)0);
acpi_leave_sleep_state(state);
/* TODO: resume devices and restore their state */
enable();
return status;
}
/****************************************************************************
*
* FUNCTION: sm_osl_power_down
*
****************************************************************************/
void
sm_osl_power_down (void)
{
/* Power down the system (S5 = soft off). */
sm_osl_suspend(ACPI_S5);
}
/****************************************************************************
*
* FUNCTION: sm_osl_add_device
*
****************************************************************************/
acpi_status
sm_osl_add_device(
SM_CONTEXT *system)
{
u32 i = 0;
struct proc_dir_entry *bm_proc_dsdt;
if (!system) {
return(AE_BAD_PARAMETER);
}
printk("ACPI: System firmware supports");
for (i=0; i<SM_MAX_SYSTEM_STATES; i++) {
if (system->states[i]) {
printk(" S%d", i);
}
}
printk("\n");
if (system->states[ACPI_STATE_S5]) {
sm_pm_power_off = pm_power_off;
pm_power_off = sm_osl_power_down;
}
create_proc_read_entry(SM_PROC_INFO, S_IRUGO,
sm_proc_root, sm_osl_proc_read_info, (void*)system);
bm_proc_sleep = create_proc_read_entry("sleep", S_IFREG | S_IRUGO | S_IWUSR,
sm_proc_root, sm_osl_proc_read_sleep, (void*)system);
if (bm_proc_sleep)
bm_proc_sleep->write_proc = sm_osl_proc_write_sleep;
bm_proc_alarm = create_proc_read_entry("alarm", S_IFREG | S_IRUGO | S_IWUSR,
sm_proc_root,sm_osl_proc_read_alarm, NULL);
if (bm_proc_alarm)
bm_proc_alarm->write_proc = sm_osl_proc_write_alarm;
bm_proc_gpe = create_proc_read_entry("gpe", S_IFREG | S_IRUGO | S_IWUSR,
sm_proc_root,sm_osl_proc_read_gpe,NULL);
if (bm_proc_gpe)
bm_proc_gpe->write_proc = sm_osl_proc_write_gpe;
/*
* Get a wakeup address for use when we come back from sleep.
* At least on IA-32, this needs to be in low memory.
* When sleep is supported on other arch's, then we may want
* to move this out to another place, but GFP_LOW should suffice
* for now.
*/
#if 0
if (system->states[ACPI_S3] || system->states[ACPI_S4]) {
acpi_wakeup_address = (unsigned long)virt_to_phys(get_free_page(GFP_LOWMEM));
printk(KERN_INFO "ACPI: Have wakeup address 0x%8.8x\n",acpi_wakeup_address);
}
#endif
/*
* This returns more than a page, so we need to use our own file ops,
* not proc's generic ones
*/
bm_proc_dsdt = create_proc_entry(SM_PROC_DSDT, S_IRUSR, sm_proc_root);
if (bm_proc_dsdt) {
bm_proc_dsdt->proc_fops = &proc_dsdt_operations;
}
return(AE_OK);
}
/****************************************************************************
*
* FUNCTION: sm_osl_remove_device
*
****************************************************************************/
acpi_status
sm_osl_remove_device (
SM_CONTEXT *system)
{
if (!system) {
return(AE_BAD_PARAMETER);
}
remove_proc_entry(SM_PROC_INFO, sm_proc_root);
remove_proc_entry(SM_PROC_DSDT, sm_proc_root);
return(AE_OK);
}
/****************************************************************************
*
* FUNCTION: sm_osl_generate_event
*
****************************************************************************/
acpi_status
sm_osl_generate_event (
u32 event,
SM_CONTEXT *system)
{
acpi_status status = AE_OK;
if (!system) {
return(AE_BAD_PARAMETER);
}
switch (event) {
default:
return(AE_BAD_PARAMETER);
break;
}
return(status);
}
/****************************************************************************
*
* FUNCTION: sm_osl_init
*
* PARAMETERS: <none>
*
* RETURN: 0: Success
*
* DESCRIPTION: Module initialization.
*
****************************************************************************/
static int __init
sm_osl_init (void)
{
acpi_status status = AE_OK;
/* abort if no busmgr */
if (!bm_proc_root)
return -ENODEV;
sm_proc_root = bm_proc_root;
if (!sm_proc_root) {
status = AE_ERROR;
}
else {
status = sm_initialize();
}
return (ACPI_SUCCESS(status)) ? 0 : -ENODEV;
}
/****************************************************************************
*
* FUNCTION: sm_osl_cleanup
*
* PARAMETERS: <none>
*
* RETURN: <none>
*
* DESCRIPTION: Module cleanup.
*
****************************************************************************/
static void __exit
sm_osl_cleanup (void)
{
sm_terminate();
return;
}
module_init(sm_osl_init);
module_exit(sm_osl_cleanup);
|