2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* 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/list.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/pm.h>
|
2005-11-14 01:06:25 +01:00
|
|
|
#include <linux/pm_legacy.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#ifdef CONFIG_X86
|
|
|
|
#include <asm/mpspec.h>
|
|
|
|
#endif
|
|
|
|
#include <acpi/acpi_bus.h>
|
|
|
|
#include <acpi/acpi_drivers.h>
|
|
|
|
|
|
|
|
#define _COMPONENT ACPI_BUS_COMPONENT
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_MODULE_NAME("acpi_bus")
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef CONFIG_X86
|
|
|
|
extern void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger);
|
|
|
|
#endif
|
|
|
|
|
ACPI: ACPICA 20060331
Implemented header file support for the following
additional ACPI tables: ASF!, BOOT, CPEP, DBGP, MCFG, SPCR,
SPMI, TCPA, and WDRT. With this support, all current and
known ACPI tables are now defined in the ACPICA headers and
are available for use by device drivers and other software.
Implemented support to allow tables that contain ACPI
names with invalid characters to be loaded. Previously,
this would cause the table load to fail, but since
there are several known cases of such tables on
existing machines, this change was made to enable
ACPI support for them. Also, this matches the
behavior of the Microsoft ACPI implementation.
https://bugzilla.novell.com/show_bug.cgi?id=147621
Fixed a couple regressions introduced during the memory
optimization in the 20060317 release. The namespace
node definition required additional reorganization and
an internal datatype that had been changed to 8-bit was
restored to 32-bit. (Valery Podrezov)
Fixed a problem where a null pointer passed to
acpi_ut_delete_generic_state() could be passed through
to acpi_os_release_object which is unexpected. Such
null pointers are now trapped and ignored, matching
the behavior of the previous implementation before the
deployment of acpi_os_release_object(). (Valery Podrezov,
Fiodor Suietov)
Fixed a memory mapping leak during the deletion of
a SystemMemory operation region where a cached memory
mapping was not deleted. This became a noticeable problem
for operation regions that are defined within frequently
used control methods. (Dana Meyers)
Reorganized the ACPI table header files into two main
files: one for the ACPI tables consumed by the ACPICA core,
and another for the miscellaneous ACPI tables that are
consumed by the drivers and other software. The various
FADT definitions were merged into one common section and
three different tables (ACPI 1.0, 1.0+, and 2.0)
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2006-03-31 07:00:00 +02:00
|
|
|
struct fadt_descriptor acpi_fadt;
|
2005-04-17 00:20:36 +02:00
|
|
|
EXPORT_SYMBOL(acpi_fadt);
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
struct acpi_device *acpi_root;
|
|
|
|
struct proc_dir_entry *acpi_root_dir;
|
2005-04-17 00:20:36 +02:00
|
|
|
EXPORT_SYMBOL(acpi_root_dir);
|
|
|
|
|
|
|
|
#define STRUCT_TO_INT(s) (*((int*)&s))
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Device Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-05 06:44:28 +02:00
|
|
|
acpi_status status = AE_OK;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE("acpi_bus_get_device");
|
|
|
|
|
|
|
|
if (!device)
|
|
|
|
return_VALUE(-EINVAL);
|
|
|
|
|
|
|
|
/* TBD: Support fixed-feature devices */
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status) || !*device) {
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_WARN, "No context for object [%p]\n",
|
2005-08-05 06:44:28 +02:00
|
|
|
handle));
|
2005-04-17 00:20:36 +02:00
|
|
|
return_VALUE(-ENODEV);
|
|
|
|
}
|
|
|
|
|
|
|
|
return_VALUE(0);
|
|
|
|
}
|
2005-08-05 06:44:28 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
EXPORT_SYMBOL(acpi_bus_get_device);
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
int acpi_bus_get_status(struct acpi_device *device)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-05 06:44:28 +02:00
|
|
|
acpi_status status = AE_OK;
|
|
|
|
unsigned long sta = 0;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
ACPI_FUNCTION_TRACE("acpi_bus_get_status");
|
|
|
|
|
|
|
|
if (!device)
|
|
|
|
return_VALUE(-EINVAL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Evaluate _STA if present.
|
|
|
|
*/
|
|
|
|
if (device->flags.dynamic_status) {
|
2005-08-05 06:44:28 +02:00
|
|
|
status =
|
|
|
|
acpi_evaluate_integer(device->handle, "_STA", NULL, &sta);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return_VALUE(-ENODEV);
|
2005-08-05 06:44:28 +02:00
|
|
|
STRUCT_TO_INT(device->status) = (int)sta;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Otherwise we assume the status of our parent (unless we don't
|
|
|
|
* have one, in which case status is implied).
|
|
|
|
*/
|
|
|
|
else if (device->parent)
|
|
|
|
device->status = device->parent->status;
|
|
|
|
else
|
|
|
|
STRUCT_TO_INT(device->status) = 0x0F;
|
|
|
|
|
|
|
|
if (device->status.functional && !device->status.present) {
|
|
|
|
printk(KERN_WARNING PREFIX "Device [%s] status [%08x]: "
|
2005-08-05 06:44:28 +02:00
|
|
|
"functional but not present; setting present\n",
|
|
|
|
device->pnp.bus_id, (u32) STRUCT_TO_INT(device->status));
|
2005-04-17 00:20:36 +02:00
|
|
|
device->status.present = 1;
|
|
|
|
}
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
|
|
|
|
device->pnp.bus_id,
|
|
|
|
(u32) STRUCT_TO_INT(device->status)));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return_VALUE(0);
|
|
|
|
}
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
EXPORT_SYMBOL(acpi_bus_get_status);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Power Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
int acpi_bus_get_power(acpi_handle handle, int *state)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-05 06:44:28 +02:00
|
|
|
int result = 0;
|
|
|
|
acpi_status status = 0;
|
|
|
|
struct acpi_device *device = NULL;
|
|
|
|
unsigned long psc = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE("acpi_bus_get_power");
|
|
|
|
|
|
|
|
result = acpi_bus_get_device(handle, &device);
|
|
|
|
if (result)
|
|
|
|
return_VALUE(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;
|
2005-08-05 06:44:28 +02:00
|
|
|
} else {
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Get the device's power state either directly (via _PSC) or
|
|
|
|
* indirectly (via power resources).
|
|
|
|
*/
|
|
|
|
if (device->power.flags.explicit_get) {
|
2005-08-05 06:44:28 +02:00
|
|
|
status = acpi_evaluate_integer(device->handle, "_PSC",
|
|
|
|
NULL, &psc);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return_VALUE(-ENODEV);
|
2005-08-05 06:44:28 +02:00
|
|
|
device->power.state = (int)psc;
|
|
|
|
} else if (device->power.flags.power_resources) {
|
2005-04-17 00:20:36 +02:00
|
|
|
result = acpi_power_get_inferred_state(device);
|
|
|
|
if (result)
|
|
|
|
return_VALUE(result);
|
|
|
|
}
|
|
|
|
|
|
|
|
*state = device->power.state;
|
|
|
|
}
|
|
|
|
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n",
|
2005-08-05 06:44:28 +02:00
|
|
|
device->pnp.bus_id, device->power.state));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return_VALUE(0);
|
|
|
|
}
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
EXPORT_SYMBOL(acpi_bus_get_power);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
int acpi_bus_set_power(acpi_handle handle, int state)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-05 06:44:28 +02:00
|
|
|
int result = 0;
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
struct acpi_device *device = NULL;
|
|
|
|
char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' };
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE("acpi_bus_set_power");
|
|
|
|
|
|
|
|
result = acpi_bus_get_device(handle, &device);
|
|
|
|
if (result)
|
|
|
|
return_VALUE(result);
|
|
|
|
|
|
|
|
if ((state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
|
|
|
|
return_VALUE(-EINVAL);
|
|
|
|
|
|
|
|
/* Make sure this is a valid target state */
|
|
|
|
|
|
|
|
if (!device->flags.power_manageable) {
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_WARN,
|
|
|
|
"Device is not power manageable\n"));
|
2005-04-17 00:20:36 +02:00
|
|
|
return_VALUE(-ENODEV);
|
|
|
|
}
|
2005-03-19 06:16:18 +01:00
|
|
|
/*
|
|
|
|
* Get device's current power state if it's unknown
|
|
|
|
* This means device power state isn't initialized or previous setting failed
|
|
|
|
*/
|
2006-05-08 06:00:00 +02:00
|
|
|
if (!device->flags.force_power_state) {
|
|
|
|
if (device->power.state == ACPI_STATE_UNKNOWN)
|
|
|
|
acpi_bus_get_power(device->handle, &device->power.state);
|
|
|
|
if (state == device->power.state) {
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n",
|
|
|
|
state));
|
|
|
|
return_VALUE(0);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
if (!device->power.states[state].flags.valid) {
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Device does not support D%d\n",
|
|
|
|
state));
|
2005-04-17 00:20:36 +02:00
|
|
|
return_VALUE(-ENODEV);
|
|
|
|
}
|
|
|
|
if (device->parent && (state < device->parent->power.state)) {
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_WARN,
|
|
|
|
"Cannot set device to a higher-powered state than parent\n"));
|
2005-04-17 00:20:36 +02:00
|
|
|
return_VALUE(-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.
|
2005-03-19 06:16:18 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
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) {
|
2005-08-05 06:44:28 +02:00
|
|
|
status = acpi_evaluate_object(device->handle,
|
|
|
|
object_name, NULL, NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
result = -ENODEV;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
}
|
2005-08-05 06:44:28 +02:00
|
|
|
} else {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (device->power.states[state].flags.explicit_set) {
|
2005-08-05 06:44:28 +02:00
|
|
|
status = acpi_evaluate_object(device->handle,
|
|
|
|
object_name, NULL, NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
result = -ENODEV;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (device->power.flags.power_resources) {
|
|
|
|
result = acpi_power_transition(device, state);
|
|
|
|
if (result)
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
end:
|
2005-04-17 00:20:36 +02:00
|
|
|
if (result)
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_WARN,
|
|
|
|
"Error transitioning device [%s] to D%d\n",
|
|
|
|
device->pnp.bus_id, state));
|
2005-04-17 00:20:36 +02:00
|
|
|
else
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Device [%s] transitioned to D%d\n",
|
|
|
|
device->pnp.bus_id, state));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return_VALUE(result);
|
|
|
|
}
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
EXPORT_SYMBOL(acpi_bus_set_power);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Event Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static DEFINE_SPINLOCK(acpi_bus_event_lock);
|
|
|
|
|
|
|
|
LIST_HEAD(acpi_bus_event_list);
|
|
|
|
DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
extern int event_is_open;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
int acpi_bus_generate_event(struct acpi_device *device, u8 type, int data)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-05 06:44:28 +02:00
|
|
|
struct acpi_bus_event *event = NULL;
|
|
|
|
unsigned long flags = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE("acpi_bus_generate_event");
|
|
|
|
|
|
|
|
if (!device)
|
|
|
|
return_VALUE(-EINVAL);
|
|
|
|
|
|
|
|
/* drop event on the floor if no one's listening */
|
|
|
|
if (!event_is_open)
|
|
|
|
return_VALUE(0);
|
|
|
|
|
|
|
|
event = kmalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);
|
|
|
|
if (!event)
|
|
|
|
return_VALUE(-ENOMEM);
|
|
|
|
|
|
|
|
strcpy(event->device_class, device->pnp.device_class);
|
|
|
|
strcpy(event->bus_id, device->pnp.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_VALUE(0);
|
|
|
|
}
|
2005-08-05 06:44:28 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
EXPORT_SYMBOL(acpi_bus_generate_event);
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
int acpi_bus_receive_event(struct acpi_bus_event *event)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-05 06:44:28 +02:00
|
|
|
unsigned long flags = 0;
|
|
|
|
struct acpi_bus_event *entry = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE("acpi_bus_receive_event");
|
|
|
|
|
|
|
|
if (!event)
|
|
|
|
return_VALUE(-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_VALUE(-ERESTARTSYS);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&acpi_bus_event_lock, flags);
|
2005-08-05 06:44:28 +02:00
|
|
|
entry =
|
|
|
|
list_entry(acpi_bus_event_list.next, struct acpi_bus_event, node);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (entry)
|
|
|
|
list_del(&entry->node);
|
|
|
|
spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
|
|
|
|
|
|
|
|
if (!entry)
|
|
|
|
return_VALUE(-ENODEV);
|
|
|
|
|
|
|
|
memcpy(event, entry, sizeof(struct acpi_bus_event));
|
|
|
|
|
|
|
|
kfree(entry);
|
|
|
|
|
|
|
|
return_VALUE(0);
|
|
|
|
}
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
EXPORT_SYMBOL(acpi_bus_receive_event);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Notification Handling
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static int
|
2005-08-05 06:44:28 +02:00
|
|
|
acpi_bus_check_device(struct acpi_device *device, int *status_changed)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-05 06:44:28 +02:00
|
|
|
acpi_status status = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct acpi_device_status old_status;
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE("acpi_bus_check_device");
|
|
|
|
|
|
|
|
if (!device)
|
|
|
|
return_VALUE(-EINVAL);
|
|
|
|
|
|
|
|
if (status_changed)
|
|
|
|
*status_changed = 0;
|
|
|
|
|
|
|
|
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;
|
|
|
|
if (STRUCT_TO_INT(old_status) != STRUCT_TO_INT(device->status)) {
|
|
|
|
if (status_changed)
|
|
|
|
*status_changed = 1;
|
|
|
|
}
|
|
|
|
return_VALUE(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
status = acpi_bus_get_status(device);
|
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return_VALUE(-ENODEV);
|
|
|
|
|
|
|
|
if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status))
|
|
|
|
return_VALUE(0);
|
|
|
|
|
|
|
|
if (status_changed)
|
|
|
|
*status_changed = 1;
|
2005-08-05 06:44:28 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Device Insertion/Removal
|
|
|
|
*/
|
|
|
|
if ((device->status.present) && !(old_status.present)) {
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device insertion detected\n"));
|
|
|
|
/* TBD: Handle device insertion */
|
2005-08-05 06:44:28 +02:00
|
|
|
} else if (!(device->status.present) && (old_status.present)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n"));
|
|
|
|
/* TBD: Handle device removal */
|
|
|
|
}
|
|
|
|
|
|
|
|
return_VALUE(0);
|
|
|
|
}
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
static int acpi_bus_check_scope(struct acpi_device *device)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-05 06:44:28 +02:00
|
|
|
int result = 0;
|
|
|
|
int status_changed = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE("acpi_bus_check_scope");
|
|
|
|
|
|
|
|
if (!device)
|
|
|
|
return_VALUE(-EINVAL);
|
|
|
|
|
|
|
|
/* Status Change? */
|
|
|
|
result = acpi_bus_check_device(device, &status_changed);
|
|
|
|
if (result)
|
|
|
|
return_VALUE(result);
|
|
|
|
|
|
|
|
if (!status_changed)
|
|
|
|
return_VALUE(0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TBD: Enumerate child devices within this device's scope and
|
|
|
|
* run acpi_bus_check_device()'s on them.
|
|
|
|
*/
|
|
|
|
|
|
|
|
return_VALUE(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_bus_notify
|
|
|
|
* ---------------
|
|
|
|
* Callback for all 'system-level' device notifications (values 0x00-0x7F).
|
|
|
|
*/
|
2005-08-05 06:44:28 +02:00
|
|
|
static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-05 06:44:28 +02:00
|
|
|
int result = 0;
|
|
|
|
struct acpi_device *device = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE("acpi_bus_notify");
|
|
|
|
|
|
|
|
if (acpi_bus_get_device(handle, &device))
|
|
|
|
return_VOID;
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_BUS_CHECK:
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Received BUS CHECK notification for device [%s]\n",
|
|
|
|
device->pnp.bus_id));
|
2005-04-17 00:20:36 +02:00
|
|
|
result = acpi_bus_check_scope(device);
|
|
|
|
/*
|
|
|
|
* TBD: We'll need to outsource certain events to non-ACPI
|
2005-08-05 06:44:28 +02:00
|
|
|
* drivers via the device manager (device.c).
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_DEVICE_CHECK:
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Received DEVICE CHECK notification for device [%s]\n",
|
|
|
|
device->pnp.bus_id));
|
2005-04-17 00:20:36 +02:00
|
|
|
result = acpi_bus_check_device(device, NULL);
|
|
|
|
/*
|
|
|
|
* TBD: We'll need to outsource certain events to non-ACPI
|
2005-08-05 06:44:28 +02:00
|
|
|
* drivers via the device manager (device.c).
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_DEVICE_WAKE:
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Received DEVICE WAKE notification for device [%s]\n",
|
|
|
|
device->pnp.bus_id));
|
2005-04-17 00:20:36 +02:00
|
|
|
/* TBD */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_EJECT_REQUEST:
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Received EJECT REQUEST notification for device [%s]\n",
|
|
|
|
device->pnp.bus_id));
|
2005-04-17 00:20:36 +02:00
|
|
|
/* TBD */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Received DEVICE CHECK LIGHT notification for device [%s]\n",
|
|
|
|
device->pnp.bus_id));
|
2005-04-17 00:20:36 +02:00
|
|
|
/* TBD: Exactly what does 'light' mean? */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_FREQUENCY_MISMATCH:
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Received FREQUENCY MISMATCH notification for device [%s]\n",
|
|
|
|
device->pnp.bus_id));
|
2005-04-17 00:20:36 +02:00
|
|
|
/* TBD */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_BUS_MODE_MISMATCH:
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Received BUS MODE MISMATCH notification for device [%s]\n",
|
|
|
|
device->pnp.bus_id));
|
2005-04-17 00:20:36 +02:00
|
|
|
/* TBD */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_POWER_FAULT:
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Received POWER FAULT notification for device [%s]\n",
|
|
|
|
device->pnp.bus_id));
|
2005-04-17 00:20:36 +02:00
|
|
|
/* TBD */
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2005-08-05 06:44:28 +02:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Received unknown/unsupported notification [%08x]\n",
|
|
|
|
type));
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return_VOID;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Initialization/Cleanup
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
static int __init acpi_bus_init_irq(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-05 06:44:28 +02:00
|
|
|
acpi_status status = AE_OK;
|
|
|
|
union acpi_object arg = { ACPI_TYPE_INTEGER };
|
|
|
|
struct acpi_object_list arg_list = { 1, &arg };
|
|
|
|
char *message = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE("acpi_bus_init_irq");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
default:
|
|
|
|
printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
|
|
|
|
return_VALUE(-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_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PIC\n"));
|
|
|
|
return_VALUE(-ENODEV);
|
|
|
|
}
|
|
|
|
|
|
|
|
return_VALUE(0);
|
|
|
|
}
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
void __init acpi_early_init(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-05 06:44:28 +02:00
|
|
|
acpi_status status = AE_OK;
|
|
|
|
struct acpi_buffer buffer = { sizeof(acpi_fadt), &acpi_fadt };
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE("acpi_early_init");
|
|
|
|
|
|
|
|
if (acpi_disabled)
|
|
|
|
return_VOID;
|
|
|
|
|
2006-03-17 22:44:00 +01:00
|
|
|
printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* enable workarounds, unless strict ACPI spec. compliance */
|
|
|
|
if (!acpi_strict)
|
|
|
|
acpi_gbl_enable_interpreter_slack = TRUE;
|
|
|
|
|
|
|
|
status = acpi_initialize_subsystem();
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2005-08-05 06:44:28 +02:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Unable to initialize the ACPI Interpreter\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
goto error0;
|
|
|
|
}
|
|
|
|
|
|
|
|
status = acpi_load_tables();
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2005-08-05 06:44:28 +02:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Unable to load the System Description Tables\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
goto error0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get a separate copy of the FADT for use by other drivers.
|
|
|
|
*/
|
ACPI: ACPICA 20060421
Removed a device initialization optimization introduced in
20051216 where the _STA method was not run unless an _INI
was also present for the same device. This optimization
could cause problems because it could allow _INI methods
to be run within a not-present device subtree (If a
not-present device had no _INI, _STA would not be run,
the not-present status would not be discovered, and the
children of the device would be incorrectly traversed.)
Implemented a new _STA optimization where namespace
subtrees that do not contain _INI are identified and
ignored during device initialization. Selectively running
_STA can significantly improve boot time on large machines
(with assistance from Len Brown.)
Implemented support for the device initialization case
where the returned _STA flags indicate a device not-present
but functioning. In this case, _INI is not run, but the
device children are examined for presence, as per the
ACPI specification.
Implemented an additional change to the IndexField support
in order to conform to MS behavior. The value written to
the Index Register is not simply a byte offset, it is a
byte offset in units of the access width of the parent
Index Field. (Fiodor Suietov)
Defined and deployed a new OSL interface,
acpi_os_validate_address(). This interface is called during
the creation of all AML operation regions, and allows
the host OS to exert control over what addresses it will
allow the AML code to access. Operation Regions whose
addresses are disallowed will cause a runtime exception
when they are actually accessed (will not affect or abort
table loading.)
Defined and deployed a new OSL interface,
acpi_os_validate_interface(). This interface allows the host OS
to match the various "optional" interface/behavior strings
for the _OSI predefined control method as appropriate
(with assistance from Bjorn Helgaas.)
Restructured and corrected various problems in the
exception handling code paths within DsCallControlMethod
and DsTerminateControlMethod in dsmethod (with assistance
from Takayoshi Kochi.)
Modified the Linux source converter to ignore quoted string
literals while converting identifiers from mixed to lower
case. This will correct problems with the disassembler
and other areas where such strings must not be modified.
The ACPI_FUNCTION_* macros no longer require quotes around
the function name. This allows the Linux source converter
to convert the names, now that the converter ignores
quoted strings.
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2006-04-21 23:15:00 +02:00
|
|
|
status = acpi_get_table(ACPI_TABLE_ID_FADT, 1, &buffer);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
printk(KERN_ERR PREFIX "Unable to get the FADT\n");
|
|
|
|
goto error0;
|
|
|
|
}
|
|
|
|
#ifdef CONFIG_X86
|
|
|
|
if (!acpi_ioapic) {
|
|
|
|
extern acpi_interrupt_flags acpi_sci_flags;
|
|
|
|
|
|
|
|
/* compatible (0) means level (3) */
|
|
|
|
if (acpi_sci_flags.trigger == 0)
|
|
|
|
acpi_sci_flags.trigger = 3;
|
|
|
|
|
|
|
|
/* Set PIC-mode SCI trigger type */
|
2005-08-05 06:44:28 +02:00
|
|
|
acpi_pic_sci_set_trigger(acpi_fadt.sci_int,
|
|
|
|
acpi_sci_flags.trigger);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
|
|
|
extern int acpi_sci_override_gsi;
|
|
|
|
/*
|
|
|
|
* now that acpi_fadt is initialized,
|
|
|
|
* update it with result from INT_SRC_OVR parsing
|
|
|
|
*/
|
|
|
|
acpi_fadt.sci_int = acpi_sci_override_gsi;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
status =
|
|
|
|
acpi_enable_subsystem(~
|
|
|
|
(ACPI_NO_HARDWARE_INIT |
|
|
|
|
ACPI_NO_ACPI_ENABLE));
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
|
|
|
|
goto error0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return_VOID;
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
error0:
|
2005-04-17 00:20:36 +02:00
|
|
|
disable_acpi();
|
|
|
|
return_VOID;
|
|
|
|
}
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
static int __init acpi_bus_init(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-05 06:44:28 +02:00
|
|
|
int result = 0;
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
extern acpi_status acpi_os_initialize1(void);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE("acpi_bus_init");
|
|
|
|
|
|
|
|
status = acpi_os_initialize1();
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
status =
|
|
|
|
acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2005-08-05 06:44:28 +02:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Unable to start the ACPI Interpreter\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
goto error1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2005-08-05 06:44:28 +02:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Unable to initialize ACPI OS objects\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
goto error1;
|
|
|
|
}
|
|
|
|
#ifdef CONFIG_ACPI_EC
|
|
|
|
/*
|
|
|
|
* 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. */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
|
|
|
|
goto error1;
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_INFO PREFIX "Interpreter enabled\n");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the system interrupt model and evaluate \_PIC.
|
|
|
|
*/
|
|
|
|
result = acpi_bus_init_irq();
|
|
|
|
if (result)
|
|
|
|
goto error1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Register the for all standard device notifications.
|
|
|
|
*/
|
2005-08-05 06:44:28 +02:00
|
|
|
status =
|
|
|
|
acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
|
|
|
|
&acpi_bus_notify, NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2005-08-05 06:44:28 +02:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Unable to register for device notifications\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
goto error1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create the top ACPI proc directory
|
|
|
|
*/
|
|
|
|
acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
|
|
|
|
|
|
|
|
return_VALUE(0);
|
|
|
|
|
|
|
|
/* Mimic structured exception handling */
|
2005-08-05 06:44:28 +02:00
|
|
|
error1:
|
2005-04-17 00:20:36 +02:00
|
|
|
acpi_terminate();
|
|
|
|
return_VALUE(-ENODEV);
|
|
|
|
}
|
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
decl_subsys(acpi, NULL, NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-08-05 06:44:28 +02:00
|
|
|
static int __init acpi_init(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-08-05 06:44:28 +02:00
|
|
|
int result = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE("acpi_init");
|
|
|
|
|
|
|
|
if (acpi_disabled) {
|
|
|
|
printk(KERN_INFO PREFIX "Interpreter disabled.\n");
|
|
|
|
return_VALUE(-ENODEV);
|
|
|
|
}
|
|
|
|
|
|
|
|
firmware_register(&acpi_subsys);
|
|
|
|
|
|
|
|
result = acpi_bus_init();
|
|
|
|
|
|
|
|
if (!result) {
|
2005-11-14 01:06:25 +01:00
|
|
|
#ifdef CONFIG_PM_LEGACY
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!PM_IS_ACTIVE())
|
|
|
|
pm_active = 1;
|
|
|
|
else {
|
2005-08-05 06:44:28 +02:00
|
|
|
printk(KERN_INFO PREFIX
|
|
|
|
"APM is already active, exiting\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
disable_acpi();
|
|
|
|
result = -ENODEV;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
} else
|
|
|
|
disable_acpi();
|
|
|
|
|
|
|
|
return_VALUE(result);
|
|
|
|
}
|
|
|
|
|
|
|
|
subsys_initcall(acpi_init);
|