forked from luck/tmp_suning_uos_patched
0c99c5288e
If the ACPI power state can be got both directly and indirectly, we prefer to get it indirectly. https://bugzilla.redhat.com/show_bug.cgi?id=531916 describes a system with a _PSC method for the fan that always returns "on". There's no benefit in us always requesting the state of the fan when performing transitions - we want to do everything we can to ensure that the fan turns on when it should do, not risk hardware damage by believing the hardware when it tells us the fan is already on. Given that the Leading Other OS(tm) works fine on this machine, it seems likely that it behaves in much this way. inspired-by: Matthew Garrett <mjg@redhat.com> Signed-off-by: Zhang Rui <rui.zhang@intel.com> Signed-off-by: Len Brown <len.brown@intel.com>
1000 lines
25 KiB
C
1000 lines
25 KiB
C
/*
|
|
* acpi_bus.c - ACPI Bus Driver ($Revision: 80 $)
|
|
*
|
|
* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
|
|
*
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
*
|
|
* 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/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/list.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/pm.h>
|
|
#include <linux/device.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/acpi.h>
|
|
#ifdef CONFIG_X86
|
|
#include <asm/mpspec.h>
|
|
#endif
|
|
#include <linux/pci.h>
|
|
#include <acpi/acpi_bus.h>
|
|
#include <acpi/acpi_drivers.h>
|
|
#include <linux/dmi.h>
|
|
|
|
#include "internal.h"
|
|
|
|
#define _COMPONENT ACPI_BUS_COMPONENT
|
|
ACPI_MODULE_NAME("bus");
|
|
|
|
struct acpi_device *acpi_root;
|
|
struct proc_dir_entry *acpi_root_dir;
|
|
EXPORT_SYMBOL(acpi_root_dir);
|
|
|
|
#define STRUCT_TO_INT(s) (*((int*)&s))
|
|
|
|
static int set_power_nocheck(const struct dmi_system_id *id)
|
|
{
|
|
printk(KERN_NOTICE PREFIX "%s detected - "
|
|
"disable power check in power transistion\n", id->ident);
|
|
acpi_power_nocheck = 1;
|
|
return 0;
|
|
}
|
|
static struct dmi_system_id __cpuinitdata power_nocheck_dmi_table[] = {
|
|
{
|
|
set_power_nocheck, "HP Pavilion 05", {
|
|
DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
|
|
DMI_MATCH(DMI_SYS_VENDOR, "HP Pavilion 05"),
|
|
DMI_MATCH(DMI_PRODUCT_VERSION, "2001211RE101GLEND") }, NULL},
|
|
{},
|
|
};
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
Device Management
|
|
-------------------------------------------------------------------------- */
|
|
|
|
int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
|
|
{
|
|
acpi_status status = AE_OK;
|
|
|
|
|
|
if (!device)
|
|
return -EINVAL;
|
|
|
|
/* TBD: Support fixed-feature devices */
|
|
|
|
status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device);
|
|
if (ACPI_FAILURE(status) || !*device) {
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
|
|
handle));
|
|
return -ENODEV;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_bus_get_device);
|
|
|
|
acpi_status acpi_bus_get_status_handle(acpi_handle handle,
|
|
unsigned long long *sta)
|
|
{
|
|
acpi_status status;
|
|
|
|
status = acpi_evaluate_integer(handle, "_STA", NULL, sta);
|
|
if (ACPI_SUCCESS(status))
|
|
return AE_OK;
|
|
|
|
if (status == AE_NOT_FOUND) {
|
|
*sta = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |
|
|
ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING;
|
|
return AE_OK;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
int acpi_bus_get_status(struct acpi_device *device)
|
|
{
|
|
acpi_status status;
|
|
unsigned long long sta;
|
|
|
|
status = acpi_bus_get_status_handle(device->handle, &sta);
|
|
if (ACPI_FAILURE(status))
|
|
return -ENODEV;
|
|
|
|
STRUCT_TO_INT(device->status) = (int) sta;
|
|
|
|
if (device->status.functional && !device->status.present) {
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]: "
|
|
"functional but not present;\n",
|
|
device->pnp.bus_id,
|
|
(u32) STRUCT_TO_INT(device->status)));
|
|
}
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
|
|
device->pnp.bus_id,
|
|
(u32) STRUCT_TO_INT(device->status)));
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(acpi_bus_get_status);
|
|
|
|
void acpi_bus_private_data_handler(acpi_handle handle,
|
|
void *context)
|
|
{
|
|
return;
|
|
}
|
|
EXPORT_SYMBOL(acpi_bus_private_data_handler);
|
|
|
|
int acpi_bus_get_private_data(acpi_handle handle, void **data)
|
|
{
|
|
acpi_status status = AE_OK;
|
|
|
|
if (!*data)
|
|
return -EINVAL;
|
|
|
|
status = acpi_get_data(handle, acpi_bus_private_data_handler, data);
|
|
if (ACPI_FAILURE(status) || !*data) {
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
|
|
handle));
|
|
return -ENODEV;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(acpi_bus_get_private_data);
|
|
|
|
/* --------------------------------------------------------------------------
|
|
Power Management
|
|
-------------------------------------------------------------------------- */
|
|
|
|
int acpi_bus_get_power(acpi_handle handle, int *state)
|
|
{
|
|
int result = 0;
|
|
acpi_status status = 0;
|
|
struct acpi_device *device = NULL;
|
|
unsigned long long psc = 0;
|
|
|
|
|
|
result = acpi_bus_get_device(handle, &device);
|
|
if (result)
|
|
return result;
|
|
|
|
*state = ACPI_STATE_UNKNOWN;
|
|
|
|
if (!device->flags.power_manageable) {
|
|
/* TBD: Non-recursive algorithm for walking up hierarchy */
|
|
if (device->parent)
|
|
*state = device->parent->power.state;
|
|
else
|
|
*state = ACPI_STATE_D0;
|
|
} else {
|
|
/*
|
|
* Get the device's power state either directly (via _PSC) or
|
|
* indirectly (via power resources).
|
|
*/
|
|
if (device->power.flags.power_resources) {
|
|
result = acpi_power_get_inferred_state(device);
|
|
if (result)
|
|
return result;
|
|
} else if (device->power.flags.explicit_get) {
|
|
status = acpi_evaluate_integer(device->handle, "_PSC",
|
|
NULL, &psc);
|
|
if (ACPI_FAILURE(status))
|
|
return -ENODEV;
|
|
device->power.state = (int)psc;
|
|
}
|
|
|
|
*state = device->power.state;
|
|
}
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n",
|
|
device->pnp.bus_id, device->power.state));
|
|
|
|
return 0;
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_bus_get_power);
|
|
|
|
int acpi_bus_set_power(acpi_handle handle, int state)
|
|
{
|
|
int result = 0;
|
|
acpi_status status = AE_OK;
|
|
struct acpi_device *device = NULL;
|
|
char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' };
|
|
|
|
|
|
result = acpi_bus_get_device(handle, &device);
|
|
if (result)
|
|
return result;
|
|
|
|
if ((state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
|
|
return -EINVAL;
|
|
|
|
/* Make sure this is a valid target state */
|
|
|
|
if (!device->flags.power_manageable) {
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device `[%s]' is not power manageable\n",
|
|
kobject_name(&device->dev.kobj)));
|
|
return -ENODEV;
|
|
}
|
|
/*
|
|
* Get device's current power state
|
|
*/
|
|
if (!acpi_power_nocheck) {
|
|
/*
|
|
* Maybe the incorrect power state is returned on the bogus
|
|
* bios, which is different with the real power state.
|
|
* For example: the bios returns D0 state and the real power
|
|
* state is D3. OS expects to set the device to D0 state. In
|
|
* such case if OS uses the power state returned by the BIOS,
|
|
* the device can't be transisted to the correct power state.
|
|
* So if the acpi_power_nocheck is set, it is unnecessary to
|
|
* get the power state by calling acpi_bus_get_power.
|
|
*/
|
|
acpi_bus_get_power(device->handle, &device->power.state);
|
|
}
|
|
if ((state == device->power.state) && !device->flags.force_power_state) {
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n",
|
|
state));
|
|
return 0;
|
|
}
|
|
|
|
if (!device->power.states[state].flags.valid) {
|
|
printk(KERN_WARNING PREFIX "Device does not support D%d\n", state);
|
|
return -ENODEV;
|
|
}
|
|
if (device->parent && (state < device->parent->power.state)) {
|
|
printk(KERN_WARNING PREFIX
|
|
"Cannot set device to a higher-powered"
|
|
" state than parent\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
/*
|
|
* Transition Power
|
|
* ----------------
|
|
* On transitions to a high-powered state we first apply power (via
|
|
* power resources) then evalute _PSx. Conversly for transitions to
|
|
* a lower-powered state.
|
|
*/
|
|
if (state < device->power.state) {
|
|
if (device->power.flags.power_resources) {
|
|
result = acpi_power_transition(device, state);
|
|
if (result)
|
|
goto end;
|
|
}
|
|
if (device->power.states[state].flags.explicit_set) {
|
|
status = acpi_evaluate_object(device->handle,
|
|
object_name, NULL, NULL);
|
|
if (ACPI_FAILURE(status)) {
|
|
result = -ENODEV;
|
|
goto end;
|
|
}
|
|
}
|
|
} else {
|
|
if (device->power.states[state].flags.explicit_set) {
|
|
status = acpi_evaluate_object(device->handle,
|
|
object_name, NULL, NULL);
|
|
if (ACPI_FAILURE(status)) {
|
|
result = -ENODEV;
|
|
goto end;
|
|
}
|
|
}
|
|
if (device->power.flags.power_resources) {
|
|
result = acpi_power_transition(device, state);
|
|
if (result)
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
end:
|
|
if (result)
|
|
printk(KERN_WARNING PREFIX
|
|
"Device [%s] failed to transition to D%d\n",
|
|
device->pnp.bus_id, state);
|
|
else {
|
|
device->power.state = state;
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
"Device [%s] transitioned to D%d\n",
|
|
device->pnp.bus_id, state));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_bus_set_power);
|
|
|
|
bool acpi_bus_power_manageable(acpi_handle handle)
|
|
{
|
|
struct acpi_device *device;
|
|
int result;
|
|
|
|
result = acpi_bus_get_device(handle, &device);
|
|
return result ? false : device->flags.power_manageable;
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_bus_power_manageable);
|
|
|
|
bool acpi_bus_can_wakeup(acpi_handle handle)
|
|
{
|
|
struct acpi_device *device;
|
|
int result;
|
|
|
|
result = acpi_bus_get_device(handle, &device);
|
|
return result ? false : device->wakeup.flags.valid;
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_bus_can_wakeup);
|
|
|
|
static void acpi_print_osc_error(acpi_handle handle,
|
|
struct acpi_osc_context *context, char *error)
|
|
{
|
|
struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER};
|
|
int i;
|
|
|
|
if (ACPI_FAILURE(acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer)))
|
|
printk(KERN_DEBUG "%s\n", error);
|
|
else {
|
|
printk(KERN_DEBUG "%s:%s\n", (char *)buffer.pointer, error);
|
|
kfree(buffer.pointer);
|
|
}
|
|
printk(KERN_DEBUG"_OSC request data:");
|
|
for (i = 0; i < context->cap.length; i += sizeof(u32))
|
|
printk("%x ", *((u32 *)(context->cap.pointer + i)));
|
|
printk("\n");
|
|
}
|
|
|
|
static u8 hex_val(unsigned char c)
|
|
{
|
|
return isdigit(c) ? c - '0' : toupper(c) - 'A' + 10;
|
|
}
|
|
|
|
static acpi_status acpi_str_to_uuid(char *str, u8 *uuid)
|
|
{
|
|
int i;
|
|
static int opc_map_to_uuid[16] = {6, 4, 2, 0, 11, 9, 16, 14, 19, 21,
|
|
24, 26, 28, 30, 32, 34};
|
|
|
|
if (strlen(str) != 36)
|
|
return AE_BAD_PARAMETER;
|
|
for (i = 0; i < 36; i++) {
|
|
if (i == 8 || i == 13 || i == 18 || i == 23) {
|
|
if (str[i] != '-')
|
|
return AE_BAD_PARAMETER;
|
|
} else if (!isxdigit(str[i]))
|
|
return AE_BAD_PARAMETER;
|
|
}
|
|
for (i = 0; i < 16; i++) {
|
|
uuid[i] = hex_val(str[opc_map_to_uuid[i]]) << 4;
|
|
uuid[i] |= hex_val(str[opc_map_to_uuid[i] + 1]);
|
|
}
|
|
return AE_OK;
|
|
}
|
|
|
|
acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context)
|
|
{
|
|
acpi_status status;
|
|
struct acpi_object_list input;
|
|
union acpi_object in_params[4];
|
|
union acpi_object *out_obj;
|
|
u8 uuid[16];
|
|
u32 errors;
|
|
struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
|
|
|
|
if (!context)
|
|
return AE_ERROR;
|
|
if (ACPI_FAILURE(acpi_str_to_uuid(context->uuid_str, uuid)))
|
|
return AE_ERROR;
|
|
context->ret.length = ACPI_ALLOCATE_BUFFER;
|
|
context->ret.pointer = NULL;
|
|
|
|
/* Setting up input parameters */
|
|
input.count = 4;
|
|
input.pointer = in_params;
|
|
in_params[0].type = ACPI_TYPE_BUFFER;
|
|
in_params[0].buffer.length = 16;
|
|
in_params[0].buffer.pointer = uuid;
|
|
in_params[1].type = ACPI_TYPE_INTEGER;
|
|
in_params[1].integer.value = context->rev;
|
|
in_params[2].type = ACPI_TYPE_INTEGER;
|
|
in_params[2].integer.value = context->cap.length/sizeof(u32);
|
|
in_params[3].type = ACPI_TYPE_BUFFER;
|
|
in_params[3].buffer.length = context->cap.length;
|
|
in_params[3].buffer.pointer = context->cap.pointer;
|
|
|
|
status = acpi_evaluate_object(handle, "_OSC", &input, &output);
|
|
if (ACPI_FAILURE(status))
|
|
return status;
|
|
|
|
if (!output.length)
|
|
return AE_NULL_OBJECT;
|
|
|
|
out_obj = output.pointer;
|
|
if (out_obj->type != ACPI_TYPE_BUFFER
|
|
|| out_obj->buffer.length != context->cap.length) {
|
|
acpi_print_osc_error(handle, context,
|
|
"_OSC evaluation returned wrong type");
|
|
status = AE_TYPE;
|
|
goto out_kfree;
|
|
}
|
|
/* Need to ignore the bit0 in result code */
|
|
errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0);
|
|
if (errors) {
|
|
if (errors & OSC_REQUEST_ERROR)
|
|
acpi_print_osc_error(handle, context,
|
|
"_OSC request failed");
|
|
if (errors & OSC_INVALID_UUID_ERROR)
|
|
acpi_print_osc_error(handle, context,
|
|
"_OSC invalid UUID");
|
|
if (errors & OSC_INVALID_REVISION_ERROR)
|
|
acpi_print_osc_error(handle, context,
|
|
"_OSC invalid revision");
|
|
if (errors & OSC_CAPABILITIES_MASK_ERROR) {
|
|
if (((u32 *)context->cap.pointer)[OSC_QUERY_TYPE]
|
|
& OSC_QUERY_ENABLE)
|
|
goto out_success;
|
|
status = AE_SUPPORT;
|
|
goto out_kfree;
|
|
}
|
|
status = AE_ERROR;
|
|
goto out_kfree;
|
|
}
|
|
out_success:
|
|
context->ret.length = out_obj->buffer.length;
|
|
context->ret.pointer = kmalloc(context->ret.length, GFP_KERNEL);
|
|
if (!context->ret.pointer) {
|
|
status = AE_NO_MEMORY;
|
|
goto out_kfree;
|
|
}
|
|
memcpy(context->ret.pointer, out_obj->buffer.pointer,
|
|
context->ret.length);
|
|
status = AE_OK;
|
|
|
|
out_kfree:
|
|
kfree(output.pointer);
|
|
if (status != AE_OK)
|
|
context->ret.pointer = NULL;
|
|
return status;
|
|
}
|
|
EXPORT_SYMBOL(acpi_run_osc);
|
|
|
|
static u8 sb_uuid_str[] = "0811B06E-4A27-44F9-8D60-3CBBC22E7B48";
|
|
static void acpi_bus_osc_support(void)
|
|
{
|
|
u32 capbuf[2];
|
|
struct acpi_osc_context context = {
|
|
.uuid_str = sb_uuid_str,
|
|
.rev = 1,
|
|
.cap.length = 8,
|
|
.cap.pointer = capbuf,
|
|
};
|
|
acpi_handle handle;
|
|
|
|
capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
|
|
capbuf[OSC_SUPPORT_TYPE] = OSC_SB_PR3_SUPPORT; /* _PR3 is in use */
|
|
#ifdef CONFIG_ACPI_PROCESSOR_AGGREGATOR
|
|
capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PAD_SUPPORT;
|
|
#endif
|
|
if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
|
|
return;
|
|
if (ACPI_SUCCESS(acpi_run_osc(handle, &context)))
|
|
kfree(context.ret.pointer);
|
|
/* do we need to check the returned cap? Sounds no */
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------
|
|
Event Management
|
|
-------------------------------------------------------------------------- */
|
|
|
|
#ifdef CONFIG_ACPI_PROC_EVENT
|
|
static DEFINE_SPINLOCK(acpi_bus_event_lock);
|
|
|
|
LIST_HEAD(acpi_bus_event_list);
|
|
DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);
|
|
|
|
extern int event_is_open;
|
|
|
|
int acpi_bus_generate_proc_event4(const char *device_class, const char *bus_id, u8 type, int data)
|
|
{
|
|
struct acpi_bus_event *event;
|
|
unsigned long flags = 0;
|
|
|
|
/* drop event on the floor if no one's listening */
|
|
if (!event_is_open)
|
|
return 0;
|
|
|
|
event = kmalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);
|
|
if (!event)
|
|
return -ENOMEM;
|
|
|
|
strcpy(event->device_class, device_class);
|
|
strcpy(event->bus_id, bus_id);
|
|
event->type = type;
|
|
event->data = data;
|
|
|
|
spin_lock_irqsave(&acpi_bus_event_lock, flags);
|
|
list_add_tail(&event->node, &acpi_bus_event_list);
|
|
spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
|
|
|
|
wake_up_interruptible(&acpi_bus_event_queue);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(acpi_bus_generate_proc_event4);
|
|
|
|
int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data)
|
|
{
|
|
if (!device)
|
|
return -EINVAL;
|
|
return acpi_bus_generate_proc_event4(device->pnp.device_class,
|
|
device->pnp.bus_id, type, data);
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_bus_generate_proc_event);
|
|
|
|
int acpi_bus_receive_event(struct acpi_bus_event *event)
|
|
{
|
|
unsigned long flags = 0;
|
|
struct acpi_bus_event *entry = NULL;
|
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
|
|
|
|
if (!event)
|
|
return -EINVAL;
|
|
|
|
if (list_empty(&acpi_bus_event_list)) {
|
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
add_wait_queue(&acpi_bus_event_queue, &wait);
|
|
|
|
if (list_empty(&acpi_bus_event_list))
|
|
schedule();
|
|
|
|
remove_wait_queue(&acpi_bus_event_queue, &wait);
|
|
set_current_state(TASK_RUNNING);
|
|
|
|
if (signal_pending(current))
|
|
return -ERESTARTSYS;
|
|
}
|
|
|
|
spin_lock_irqsave(&acpi_bus_event_lock, flags);
|
|
if (!list_empty(&acpi_bus_event_list)) {
|
|
entry = list_entry(acpi_bus_event_list.next,
|
|
struct acpi_bus_event, node);
|
|
list_del(&entry->node);
|
|
}
|
|
spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
|
|
|
|
if (!entry)
|
|
return -ENODEV;
|
|
|
|
memcpy(event, entry, sizeof(struct acpi_bus_event));
|
|
|
|
kfree(entry);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif /* CONFIG_ACPI_PROC_EVENT */
|
|
|
|
/* --------------------------------------------------------------------------
|
|
Notification Handling
|
|
-------------------------------------------------------------------------- */
|
|
|
|
static void acpi_bus_check_device(acpi_handle handle)
|
|
{
|
|
struct acpi_device *device;
|
|
acpi_status status;
|
|
struct acpi_device_status old_status;
|
|
|
|
if (acpi_bus_get_device(handle, &device))
|
|
return;
|
|
if (!device)
|
|
return;
|
|
|
|
old_status = device->status;
|
|
|
|
/*
|
|
* Make sure this device's parent is present before we go about
|
|
* messing with the device.
|
|
*/
|
|
if (device->parent && !device->parent->status.present) {
|
|
device->status = device->parent->status;
|
|
return;
|
|
}
|
|
|
|
status = acpi_bus_get_status(device);
|
|
if (ACPI_FAILURE(status))
|
|
return;
|
|
|
|
if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status))
|
|
return;
|
|
|
|
/*
|
|
* Device Insertion/Removal
|
|
*/
|
|
if ((device->status.present) && !(old_status.present)) {
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device insertion detected\n"));
|
|
/* TBD: Handle device insertion */
|
|
} else if (!(device->status.present) && (old_status.present)) {
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n"));
|
|
/* TBD: Handle device removal */
|
|
}
|
|
}
|
|
|
|
static void acpi_bus_check_scope(acpi_handle handle)
|
|
{
|
|
/* Status Change? */
|
|
acpi_bus_check_device(handle);
|
|
|
|
/*
|
|
* TBD: Enumerate child devices within this device's scope and
|
|
* run acpi_bus_check_device()'s on them.
|
|
*/
|
|
}
|
|
|
|
static BLOCKING_NOTIFIER_HEAD(acpi_bus_notify_list);
|
|
int register_acpi_bus_notifier(struct notifier_block *nb)
|
|
{
|
|
return blocking_notifier_chain_register(&acpi_bus_notify_list, nb);
|
|
}
|
|
EXPORT_SYMBOL_GPL(register_acpi_bus_notifier);
|
|
|
|
void unregister_acpi_bus_notifier(struct notifier_block *nb)
|
|
{
|
|
blocking_notifier_chain_unregister(&acpi_bus_notify_list, nb);
|
|
}
|
|
EXPORT_SYMBOL_GPL(unregister_acpi_bus_notifier);
|
|
|
|
/**
|
|
* acpi_bus_notify
|
|
* ---------------
|
|
* Callback for all 'system-level' device notifications (values 0x00-0x7F).
|
|
*/
|
|
static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
|
|
{
|
|
struct acpi_device *device = NULL;
|
|
struct acpi_driver *driver;
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Notification %#02x to handle %p\n",
|
|
type, handle));
|
|
|
|
blocking_notifier_call_chain(&acpi_bus_notify_list,
|
|
type, (void *)handle);
|
|
|
|
switch (type) {
|
|
|
|
case ACPI_NOTIFY_BUS_CHECK:
|
|
acpi_bus_check_scope(handle);
|
|
/*
|
|
* TBD: We'll need to outsource certain events to non-ACPI
|
|
* drivers via the device manager (device.c).
|
|
*/
|
|
break;
|
|
|
|
case ACPI_NOTIFY_DEVICE_CHECK:
|
|
acpi_bus_check_device(handle);
|
|
/*
|
|
* TBD: We'll need to outsource certain events to non-ACPI
|
|
* drivers via the device manager (device.c).
|
|
*/
|
|
break;
|
|
|
|
case ACPI_NOTIFY_DEVICE_WAKE:
|
|
/* TBD */
|
|
break;
|
|
|
|
case ACPI_NOTIFY_EJECT_REQUEST:
|
|
/* TBD */
|
|
break;
|
|
|
|
case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
|
|
/* TBD: Exactly what does 'light' mean? */
|
|
break;
|
|
|
|
case ACPI_NOTIFY_FREQUENCY_MISMATCH:
|
|
/* TBD */
|
|
break;
|
|
|
|
case ACPI_NOTIFY_BUS_MODE_MISMATCH:
|
|
/* TBD */
|
|
break;
|
|
|
|
case ACPI_NOTIFY_POWER_FAULT:
|
|
/* TBD */
|
|
break;
|
|
|
|
default:
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
"Received unknown/unsupported notification [%08x]\n",
|
|
type));
|
|
break;
|
|
}
|
|
|
|
acpi_bus_get_device(handle, &device);
|
|
if (device) {
|
|
driver = device->driver;
|
|
if (driver && driver->ops.notify &&
|
|
(driver->flags & ACPI_DRIVER_ALL_NOTIFY_EVENTS))
|
|
driver->ops.notify(device, type);
|
|
}
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------
|
|
Initialization/Cleanup
|
|
-------------------------------------------------------------------------- */
|
|
|
|
static int __init acpi_bus_init_irq(void)
|
|
{
|
|
acpi_status status = AE_OK;
|
|
union acpi_object arg = { ACPI_TYPE_INTEGER };
|
|
struct acpi_object_list arg_list = { 1, &arg };
|
|
char *message = NULL;
|
|
|
|
|
|
/*
|
|
* Let the system know what interrupt model we are using by
|
|
* evaluating the \_PIC object, if exists.
|
|
*/
|
|
|
|
switch (acpi_irq_model) {
|
|
case ACPI_IRQ_MODEL_PIC:
|
|
message = "PIC";
|
|
break;
|
|
case ACPI_IRQ_MODEL_IOAPIC:
|
|
message = "IOAPIC";
|
|
break;
|
|
case ACPI_IRQ_MODEL_IOSAPIC:
|
|
message = "IOSAPIC";
|
|
break;
|
|
case ACPI_IRQ_MODEL_PLATFORM:
|
|
message = "platform specific model";
|
|
break;
|
|
default:
|
|
printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message);
|
|
|
|
arg.integer.value = acpi_irq_model;
|
|
|
|
status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL);
|
|
if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
|
|
ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
|
|
return -ENODEV;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
u8 acpi_gbl_permanent_mmap;
|
|
|
|
|
|
void __init acpi_early_init(void)
|
|
{
|
|
acpi_status status = AE_OK;
|
|
|
|
if (acpi_disabled)
|
|
return;
|
|
|
|
printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION);
|
|
|
|
/* enable workarounds, unless strict ACPI spec. compliance */
|
|
if (!acpi_strict)
|
|
acpi_gbl_enable_interpreter_slack = TRUE;
|
|
|
|
acpi_gbl_permanent_mmap = 1;
|
|
|
|
status = acpi_reallocate_root_table();
|
|
if (ACPI_FAILURE(status)) {
|
|
printk(KERN_ERR PREFIX
|
|
"Unable to reallocate ACPI tables\n");
|
|
goto error0;
|
|
}
|
|
|
|
status = acpi_initialize_subsystem();
|
|
if (ACPI_FAILURE(status)) {
|
|
printk(KERN_ERR PREFIX
|
|
"Unable to initialize the ACPI Interpreter\n");
|
|
goto error0;
|
|
}
|
|
|
|
status = acpi_load_tables();
|
|
if (ACPI_FAILURE(status)) {
|
|
printk(KERN_ERR PREFIX
|
|
"Unable to load the System Description Tables\n");
|
|
goto error0;
|
|
}
|
|
|
|
#ifdef CONFIG_X86
|
|
if (!acpi_ioapic) {
|
|
/* compatible (0) means level (3) */
|
|
if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) {
|
|
acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK;
|
|
acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL;
|
|
}
|
|
/* Set PIC-mode SCI trigger type */
|
|
acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt,
|
|
(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
|
|
} else {
|
|
/*
|
|
* now that acpi_gbl_FADT is initialized,
|
|
* update it with result from INT_SRC_OVR parsing
|
|
*/
|
|
acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi;
|
|
}
|
|
#endif
|
|
|
|
status =
|
|
acpi_enable_subsystem(~
|
|
(ACPI_NO_HARDWARE_INIT |
|
|
ACPI_NO_ACPI_ENABLE));
|
|
if (ACPI_FAILURE(status)) {
|
|
printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
|
|
goto error0;
|
|
}
|
|
|
|
return;
|
|
|
|
error0:
|
|
disable_acpi();
|
|
return;
|
|
}
|
|
|
|
static int __init acpi_bus_init(void)
|
|
{
|
|
int result = 0;
|
|
acpi_status status = AE_OK;
|
|
extern acpi_status acpi_os_initialize1(void);
|
|
|
|
acpi_os_initialize1();
|
|
|
|
status =
|
|
acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE);
|
|
if (ACPI_FAILURE(status)) {
|
|
printk(KERN_ERR PREFIX
|
|
"Unable to start the ACPI Interpreter\n");
|
|
goto error1;
|
|
}
|
|
|
|
/*
|
|
* ACPI 2.0 requires the EC driver to be loaded and work before
|
|
* the EC device is found in the namespace (i.e. before acpi_initialize_objects()
|
|
* is called).
|
|
*
|
|
* This is accomplished by looking for the ECDT table, and getting
|
|
* the EC parameters out of that.
|
|
*/
|
|
status = acpi_ec_ecdt_probe();
|
|
/* Ignore result. Not having an ECDT is not fatal. */
|
|
|
|
acpi_bus_osc_support();
|
|
|
|
status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
|
|
if (ACPI_FAILURE(status)) {
|
|
printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
|
|
goto error1;
|
|
}
|
|
|
|
acpi_early_processor_set_pdc();
|
|
|
|
/*
|
|
* Maybe EC region is required at bus_scan/acpi_get_devices. So it
|
|
* is necessary to enable it as early as possible.
|
|
*/
|
|
acpi_boot_ec_enable();
|
|
|
|
printk(KERN_INFO PREFIX "Interpreter enabled\n");
|
|
|
|
/* Initialize sleep structures */
|
|
acpi_sleep_init();
|
|
|
|
/*
|
|
* Get the system interrupt model and evaluate \_PIC.
|
|
*/
|
|
result = acpi_bus_init_irq();
|
|
if (result)
|
|
goto error1;
|
|
|
|
/*
|
|
* Register the for all standard device notifications.
|
|
*/
|
|
status =
|
|
acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
|
|
&acpi_bus_notify, NULL);
|
|
if (ACPI_FAILURE(status)) {
|
|
printk(KERN_ERR PREFIX
|
|
"Unable to register for device notifications\n");
|
|
goto error1;
|
|
}
|
|
|
|
/*
|
|
* Create the top ACPI proc directory
|
|
*/
|
|
acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
|
|
|
|
return 0;
|
|
|
|
/* Mimic structured exception handling */
|
|
error1:
|
|
acpi_terminate();
|
|
return -ENODEV;
|
|
}
|
|
|
|
struct kobject *acpi_kobj;
|
|
|
|
static int __init acpi_init(void)
|
|
{
|
|
int result = 0;
|
|
|
|
|
|
if (acpi_disabled) {
|
|
printk(KERN_INFO PREFIX "Interpreter disabled.\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
acpi_kobj = kobject_create_and_add("acpi", firmware_kobj);
|
|
if (!acpi_kobj) {
|
|
printk(KERN_WARNING "%s: kset create error\n", __func__);
|
|
acpi_kobj = NULL;
|
|
}
|
|
|
|
init_acpi_device_notify();
|
|
result = acpi_bus_init();
|
|
|
|
if (!result) {
|
|
pci_mmcfg_late_init();
|
|
if (!(pm_flags & PM_APM))
|
|
pm_flags |= PM_ACPI;
|
|
else {
|
|
printk(KERN_INFO PREFIX
|
|
"APM is already active, exiting\n");
|
|
disable_acpi();
|
|
result = -ENODEV;
|
|
}
|
|
} else
|
|
disable_acpi();
|
|
|
|
if (acpi_disabled)
|
|
return result;
|
|
|
|
/*
|
|
* If the laptop falls into the DMI check table, the power state check
|
|
* will be disabled in the course of device power transistion.
|
|
*/
|
|
dmi_check_system(power_nocheck_dmi_table);
|
|
|
|
acpi_scan_init();
|
|
acpi_ec_init();
|
|
acpi_power_init();
|
|
acpi_system_init();
|
|
acpi_debug_init();
|
|
acpi_sleep_proc_init();
|
|
acpi_wakeup_device_init();
|
|
return result;
|
|
}
|
|
|
|
subsys_initcall(acpi_init);
|