2005-04-17 05:20:36 +07: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>
|
2006-07-12 12:47:00 +07:00
|
|
|
#include <linux/kernel.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/pm.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/proc_fs.h>
|
2008-02-10 05:24:08 +07:00
|
|
|
#include <linux/acpi.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_X86
|
|
|
|
#include <asm/mpspec.h>
|
|
|
|
#endif
|
2008-02-15 16:27:20 +07:00
|
|
|
#include <linux/pci.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <acpi/acpi_bus.h>
|
|
|
|
#include <acpi/acpi_drivers.h>
|
2009-07-07 10:40:19 +07:00
|
|
|
#include <linux/dmi.h>
|
2011-02-11 06:04:52 +07:00
|
|
|
#include <linux/suspend.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-03-14 01:08:26 +07:00
|
|
|
#include "internal.h"
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#define _COMPONENT ACPI_BUS_COMPONENT
|
2007-02-13 10:42:12 +07:00
|
|
|
ACPI_MODULE_NAME("bus");
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
struct acpi_device *acpi_root;
|
|
|
|
struct proc_dir_entry *acpi_root_dir;
|
2005-04-17 05:20:36 +07:00
|
|
|
EXPORT_SYMBOL(acpi_root_dir);
|
|
|
|
|
|
|
|
#define STRUCT_TO_INT(s) (*((int*)&s))
|
|
|
|
|
2008-08-11 13:59:59 +07:00
|
|
|
|
2010-05-12 08:26:48 +07:00
|
|
|
#ifdef CONFIG_X86
|
2010-04-08 13:34:27 +07:00
|
|
|
static int set_copy_dsdt(const struct dmi_system_id *id)
|
|
|
|
{
|
|
|
|
printk(KERN_NOTICE "%s detected - "
|
|
|
|
"force copy of DSDT to local memory\n", id->ident);
|
|
|
|
acpi_gbl_copy_dsdt_locally = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dmi_system_id dsdt_dmi_table[] __initdata = {
|
|
|
|
/*
|
2010-09-29 09:57:02 +07:00
|
|
|
* Invoke DSDT corruption work-around on all Toshiba Satellite.
|
2010-04-08 13:34:27 +07:00
|
|
|
* https://bugzilla.kernel.org/show_bug.cgi?id=14679
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
.callback = set_copy_dsdt,
|
2010-09-29 09:57:02 +07:00
|
|
|
.ident = "TOSHIBA Satellite",
|
2010-04-08 13:34:27 +07:00
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
|
2010-09-29 09:57:02 +07:00
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"),
|
2010-04-08 13:34:27 +07:00
|
|
|
},
|
2010-05-12 08:26:48 +07:00
|
|
|
},
|
|
|
|
{}
|
2010-04-08 13:34:27 +07:00
|
|
|
};
|
2010-05-12 08:26:48 +07:00
|
|
|
#else
|
|
|
|
static struct dmi_system_id dsdt_dmi_table[] __initdata = {
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
#endif
|
2010-04-08 13:34:27 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Device Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
acpi_status status = AE_OK;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!device)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* TBD: Support fixed-feature devices */
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status) || !*device) {
|
2006-07-26 00:30:57 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
|
|
|
|
handle));
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2005-08-05 11:44:28 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
EXPORT_SYMBOL(acpi_bus_get_device);
|
|
|
|
|
2009-09-22 02:30:01 +07:00
|
|
|
acpi_status acpi_bus_get_status_handle(acpi_handle handle,
|
|
|
|
unsigned long long *sta)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-09-22 02:30:01 +07:00
|
|
|
acpi_status status;
|
2005-08-05 11:44:28 +07:00
|
|
|
|
2009-09-22 02:30:01 +07:00
|
|
|
status = acpi_evaluate_integer(handle, "_STA", NULL, sta);
|
|
|
|
if (ACPI_SUCCESS(status))
|
|
|
|
return AE_OK;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-09-22 02:30:01 +07:00
|
|
|
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;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-09-22 02:30:01 +07:00
|
|
|
return status;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-09-22 02:30:01 +07:00
|
|
|
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;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (device->status.functional && !device->status.present) {
|
2008-08-11 12:40:22 +07:00
|
|
|
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)));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
|
|
|
|
device->pnp.bus_id,
|
|
|
|
(u32) STRUCT_TO_INT(device->status)));
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2005-08-05 11:44:28 +07:00
|
|
|
EXPORT_SYMBOL(acpi_bus_get_status);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-01-17 14:51:21 +07:00
|
|
|
void acpi_bus_private_data_handler(acpi_handle handle,
|
2009-06-29 12:43:27 +07:00
|
|
|
void *context)
|
2008-01-17 14:51:21 +07:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Power Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2010-11-25 06:07:56 +07:00
|
|
|
static int __acpi_bus_get_power(struct acpi_device *device, int *state)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
int result = 0;
|
|
|
|
acpi_status status = 0;
|
2008-10-10 13:22:59 +07:00
|
|
|
unsigned long long psc = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-11-25 06:07:56 +07:00
|
|
|
if (!device || !state)
|
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
*state = ACPI_STATE_UNKNOWN;
|
|
|
|
|
2010-11-25 06:07:56 +07:00
|
|
|
if (device->flags.power_manageable) {
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2007-02-10 13:32:16 +07:00
|
|
|
* Get the device's power state either directly (via _PSC) or
|
2005-04-17 05:20:36 +07:00
|
|
|
* indirectly (via power resources).
|
|
|
|
*/
|
2009-12-17 15:02:08 +07:00
|
|
|
if (device->power.flags.power_resources) {
|
2010-11-25 06:07:56 +07:00
|
|
|
result = acpi_power_get_inferred_state(device, state);
|
2009-12-17 15:02:08 +07:00
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
} else if (device->power.flags.explicit_get) {
|
2005-08-05 11:44:28 +07:00
|
|
|
status = acpi_evaluate_integer(device->handle, "_PSC",
|
|
|
|
NULL, &psc);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status))
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2010-11-25 06:07:56 +07:00
|
|
|
*state = (int)psc;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2010-11-25 06:07:56 +07:00
|
|
|
} else {
|
|
|
|
/* TBD: Non-recursive algorithm for walking up hierarchy. */
|
|
|
|
*state = device->parent ?
|
|
|
|
device->parent->power.state : ACPI_STATE_D0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n",
|
2010-11-25 06:07:56 +07:00
|
|
|
device->pnp.bus_id, *state));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2010-11-25 06:07:56 +07:00
|
|
|
|
2010-11-25 06:09:15 +07:00
|
|
|
static int __acpi_bus_set_power(struct acpi_device *device, int state)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
int result = 0;
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' };
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-11-25 06:09:15 +07:00
|
|
|
if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Make sure this is a valid target state */
|
|
|
|
|
2010-11-25 06:11:24 +07:00
|
|
|
if (state == device->power.state) {
|
2007-02-16 14:23:07 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n",
|
|
|
|
state));
|
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2007-02-16 14:23:07 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!device->power.states[state].flags.valid) {
|
2006-06-27 10:04:31 +07:00
|
|
|
printk(KERN_WARNING PREFIX "Device does not support D%d\n", state);
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
if (device->parent && (state < device->parent->power.state)) {
|
2006-06-27 10:04:31 +07:00
|
|
|
printk(KERN_WARNING PREFIX
|
2006-06-27 10:58:43 +07:00
|
|
|
"Cannot set device to a higher-powered"
|
2006-06-27 10:04:31 +07:00
|
|
|
" state than parent\n");
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 12:16:18 +07:00
|
|
|
*/
|
2005-04-17 05:20:36 +07: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 11:44:28 +07:00
|
|
|
status = acpi_evaluate_object(device->handle,
|
|
|
|
object_name, NULL, NULL);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
result = -ENODEV;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
}
|
2005-08-05 11:44:28 +07:00
|
|
|
} else {
|
2005-04-17 05:20:36 +07:00
|
|
|
if (device->power.states[state].flags.explicit_set) {
|
2005-08-05 11:44:28 +07:00
|
|
|
status = acpi_evaluate_object(device->handle,
|
|
|
|
object_name, NULL, NULL);
|
2005-04-17 05:20:36 +07: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 11:44:28 +07:00
|
|
|
end:
|
2005-04-17 05:20:36 +07:00
|
|
|
if (result)
|
2006-06-27 10:04:31 +07:00
|
|
|
printk(KERN_WARNING PREFIX
|
2009-05-08 11:07:30 +07:00
|
|
|
"Device [%s] failed to transition to D%d\n",
|
2006-06-27 10:04:31 +07:00
|
|
|
device->pnp.bus_id, state);
|
2007-10-12 04:53:58 +07:00
|
|
|
else {
|
|
|
|
device->power.state = state;
|
2005-08-05 11:44:28 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Device [%s] transitioned to D%d\n",
|
|
|
|
device->pnp.bus_id, state));
|
2007-10-12 04:53:58 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return result;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2010-11-25 06:09:15 +07:00
|
|
|
|
|
|
|
int acpi_bus_set_power(acpi_handle handle, int state)
|
|
|
|
{
|
|
|
|
struct acpi_device *device;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
result = acpi_bus_get_device(handle, &device);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
if (!device->flags.power_manageable) {
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Device [%s] is not power manageable\n",
|
|
|
|
dev_name(&device->dev)));
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
return __acpi_bus_set_power(device, state);
|
|
|
|
}
|
2005-08-05 11:44:28 +07:00
|
|
|
EXPORT_SYMBOL(acpi_bus_set_power);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-11-25 06:08:36 +07:00
|
|
|
|
|
|
|
int acpi_bus_init_power(struct acpi_device *device)
|
|
|
|
{
|
|
|
|
int state;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
if (!device)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
device->power.state = ACPI_STATE_UNKNOWN;
|
|
|
|
|
|
|
|
result = __acpi_bus_get_power(device, &state);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
if (device->power.flags.power_resources)
|
|
|
|
result = acpi_power_on_resources(device, state);
|
|
|
|
|
|
|
|
if (!result)
|
|
|
|
device->power.state = state;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-11-25 06:09:15 +07:00
|
|
|
int acpi_bus_update_power(acpi_handle handle, int *state_p)
|
|
|
|
{
|
|
|
|
struct acpi_device *device;
|
|
|
|
int state;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
result = acpi_bus_get_device(handle, &device);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
result = __acpi_bus_get_power(device, &state);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
result = __acpi_bus_set_power(device, state);
|
|
|
|
if (!result && state_p)
|
|
|
|
*state_p = state;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(acpi_bus_update_power);
|
|
|
|
|
|
|
|
|
2008-07-07 08:30:55 +07:00
|
|
|
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);
|
|
|
|
|
2008-07-07 08:34:48 +07:00
|
|
|
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);
|
|
|
|
|
2009-10-29 10:04:28 +07:00
|
|
|
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 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++) {
|
2010-05-25 04:33:28 +07:00
|
|
|
uuid[i] = hex_to_bin(str[opc_map_to_uuid[i]]) << 4;
|
|
|
|
uuid[i] |= hex_to_bin(str[opc_map_to_uuid[i] + 1]);
|
2009-10-29 10:04:28 +07:00
|
|
|
}
|
|
|
|
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;
|
2009-12-23 16:04:11 +07:00
|
|
|
struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
|
2009-10-29 10:04:28 +07:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2009-12-23 16:04:11 +07:00
|
|
|
status = acpi_evaluate_object(handle, "_OSC", &input, &output);
|
2009-10-29 10:04:28 +07:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return status;
|
|
|
|
|
2009-12-23 16:04:11 +07:00
|
|
|
if (!output.length)
|
2009-10-29 10:04:28 +07:00
|
|
|
return AE_NULL_OBJECT;
|
|
|
|
|
2009-12-23 16:04:11 +07:00
|
|
|
out_obj = output.pointer;
|
|
|
|
if (out_obj->type != ACPI_TYPE_BUFFER
|
|
|
|
|| out_obj->buffer.length != context->cap.length) {
|
2009-10-29 10:04:28 +07:00
|
|
|
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:
|
2009-12-23 16:04:11 +07:00
|
|
|
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;
|
2009-10-29 10:04:28 +07:00
|
|
|
|
|
|
|
out_kfree:
|
2009-12-23 16:04:11 +07:00
|
|
|
kfree(output.pointer);
|
|
|
|
if (status != AE_OK)
|
|
|
|
context->ret.pointer = NULL;
|
2009-10-29 10:04:28 +07:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_run_osc);
|
|
|
|
|
2009-10-29 10:05:05 +07:00
|
|
|
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 */
|
2010-01-08 20:29:58 +07:00
|
|
|
#if defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR) ||\
|
|
|
|
defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR_MODULE)
|
2009-10-29 10:05:05 +07:00
|
|
|
capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PAD_SUPPORT;
|
|
|
|
#endif
|
2010-01-08 20:29:58 +07:00
|
|
|
|
|
|
|
#if defined(CONFIG_ACPI_PROCESSOR) || defined(CONFIG_ACPI_PROCESSOR_MODULE)
|
|
|
|
capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PPC_OST_SUPPORT;
|
|
|
|
#endif
|
2009-10-29 10:05:05 +07:00
|
|
|
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 */
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Event Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2007-08-24 02:20:26 +07:00
|
|
|
#ifdef CONFIG_ACPI_PROC_EVENT
|
2005-04-17 05:20:36 +07:00
|
|
|
static DEFINE_SPINLOCK(acpi_bus_event_lock);
|
|
|
|
|
|
|
|
LIST_HEAD(acpi_bus_event_list);
|
|
|
|
DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
extern int event_is_open;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-09-26 22:43:16 +07:00
|
|
|
int acpi_bus_generate_proc_event4(const char *device_class, const char *bus_id, u8 type, int data)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-09-26 22:43:16 +07:00
|
|
|
struct acpi_bus_event *event;
|
2005-08-05 11:44:28 +07:00
|
|
|
unsigned long flags = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* drop event on the floor if no one's listening */
|
|
|
|
if (!event_is_open)
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-04-27 05:23:37 +07:00
|
|
|
event = kzalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!event)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENOMEM;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-09-26 22:43:16 +07:00
|
|
|
strcpy(event->device_class, device_class);
|
|
|
|
strcpy(event->bus_id, bus_id);
|
2005-04-17 05:20:36 +07:00
|
|
|
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);
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2007-09-26 22:43:16 +07:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2005-08-05 11:44:28 +07:00
|
|
|
|
2007-08-24 02:20:26 +07:00
|
|
|
EXPORT_SYMBOL(acpi_bus_generate_proc_event);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
int acpi_bus_receive_event(struct acpi_bus_event *event)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
unsigned long flags = 0;
|
|
|
|
struct acpi_bus_event *entry = NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
|
|
|
|
|
|
|
|
|
|
if (!event)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
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))
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ERESTARTSYS;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&acpi_bus_event_lock, flags);
|
2008-04-16 04:34:47 +07:00
|
|
|
if (!list_empty(&acpi_bus_event_list)) {
|
|
|
|
entry = list_entry(acpi_bus_event_list.next,
|
|
|
|
struct acpi_bus_event, node);
|
2005-04-17 05:20:36 +07:00
|
|
|
list_del(&entry->node);
|
2008-04-16 04:34:47 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
|
|
|
|
|
|
|
|
if (!entry)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
memcpy(event, entry, sizeof(struct acpi_bus_event));
|
|
|
|
|
|
|
|
kfree(entry);
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-08-24 02:20:26 +07:00
|
|
|
#endif /* CONFIG_ACPI_PROC_EVENT */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Notification Handling
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2009-05-23 00:43:56 +07:00
|
|
|
static void acpi_bus_check_device(acpi_handle handle)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-05-23 00:43:56 +07:00
|
|
|
struct acpi_device *device;
|
2009-05-23 00:43:51 +07:00
|
|
|
acpi_status status;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct acpi_device_status old_status;
|
|
|
|
|
2009-05-23 00:43:56 +07:00
|
|
|
if (acpi_bus_get_device(handle, &device))
|
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!device)
|
2009-05-23 00:43:51 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
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;
|
2009-05-23 00:43:51 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
status = acpi_bus_get_status(device);
|
|
|
|
if (ACPI_FAILURE(status))
|
2009-05-23 00:43:51 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status))
|
2009-05-23 00:43:51 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07: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 11:44:28 +07:00
|
|
|
} else if (!(device->status.present) && (old_status.present)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n"));
|
|
|
|
/* TBD: Handle device removal */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-23 00:43:56 +07:00
|
|
|
static void acpi_bus_check_scope(acpi_handle handle)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
/* Status Change? */
|
2009-05-23 00:43:56 +07:00
|
|
|
acpi_bus_check_device(handle);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* TBD: Enumerate child devices within this device's scope and
|
|
|
|
* run acpi_bus_check_device()'s on them.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
2008-08-28 09:04:29 +07:00
|
|
|
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);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/**
|
|
|
|
* acpi_bus_notify
|
|
|
|
* ---------------
|
|
|
|
* Callback for all 'system-level' device notifications (values 0x00-0x7F).
|
|
|
|
*/
|
2005-08-05 11:44:28 +07:00
|
|
|
static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
struct acpi_device *device = NULL;
|
2009-04-30 22:35:37 +07:00
|
|
|
struct acpi_driver *driver;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-05-23 00:43:41 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Notification %#02x to handle %p\n",
|
|
|
|
type, handle));
|
|
|
|
|
2008-08-28 09:04:29 +07:00
|
|
|
blocking_notifier_call_chain(&acpi_bus_notify_list,
|
|
|
|
type, (void *)handle);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_BUS_CHECK:
|
2009-05-23 00:43:56 +07:00
|
|
|
acpi_bus_check_scope(handle);
|
2007-02-10 13:32:16 +07:00
|
|
|
/*
|
2005-04-17 05:20:36 +07:00
|
|
|
* TBD: We'll need to outsource certain events to non-ACPI
|
2005-08-05 11:44:28 +07:00
|
|
|
* drivers via the device manager (device.c).
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_DEVICE_CHECK:
|
2009-05-23 00:43:56 +07:00
|
|
|
acpi_bus_check_device(handle);
|
2007-02-10 13:32:16 +07:00
|
|
|
/*
|
2005-04-17 05:20:36 +07:00
|
|
|
* TBD: We'll need to outsource certain events to non-ACPI
|
2005-08-05 11:44:28 +07:00
|
|
|
* drivers via the device manager (device.c).
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
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:
|
2005-08-05 11:44:28 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Received unknown/unsupported notification [%08x]\n",
|
|
|
|
type));
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-05-23 00:43:56 +07:00
|
|
|
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);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Initialization/Cleanup
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int __init acpi_bus_init_irq(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07: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 05:20:36 +07:00
|
|
|
|
|
|
|
|
2007-02-10 13:32:16 +07:00
|
|
|
/*
|
2005-04-17 05:20:36 +07:00
|
|
|
* 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;
|
2006-12-23 00:50:04 +07:00
|
|
|
case ACPI_IRQ_MODEL_PLATFORM:
|
|
|
|
message = "platform specific model";
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
default:
|
|
|
|
printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
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)) {
|
2006-06-27 10:58:43 +07:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-06-10 12:42:13 +07:00
|
|
|
u8 acpi_gbl_permanent_mmap;
|
2007-02-02 23:48:19 +07:00
|
|
|
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
void __init acpi_early_init(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
acpi_status status = AE_OK;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (acpi_disabled)
|
2006-06-27 11:41:40 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-03-18 04:44:00 +07:00
|
|
|
printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* enable workarounds, unless strict ACPI spec. compliance */
|
|
|
|
if (!acpi_strict)
|
|
|
|
acpi_gbl_enable_interpreter_slack = TRUE;
|
|
|
|
|
2007-02-02 23:48:19 +07:00
|
|
|
acpi_gbl_permanent_mmap = 1;
|
|
|
|
|
2010-04-08 13:34:27 +07:00
|
|
|
/*
|
|
|
|
* If the machine falls into the DMI check table,
|
|
|
|
* DSDT will be copied to memory
|
|
|
|
*/
|
|
|
|
dmi_check_system(dsdt_dmi_table);
|
|
|
|
|
2007-02-02 23:48:19 +07:00
|
|
|
status = acpi_reallocate_root_table();
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Unable to reallocate ACPI tables\n");
|
|
|
|
goto error0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
status = acpi_initialize_subsystem();
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2005-08-05 11:44:28 +07:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Unable to initialize the ACPI Interpreter\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
goto error0;
|
|
|
|
}
|
|
|
|
|
|
|
|
status = acpi_load_tables();
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2005-08-05 11:44:28 +07:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Unable to load the System Description Tables\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
goto error0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86
|
|
|
|
if (!acpi_ioapic) {
|
|
|
|
/* compatible (0) means level (3) */
|
2007-02-02 23:48:22 +07:00
|
|
|
if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) {
|
|
|
|
acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK;
|
|
|
|
acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Set PIC-mode SCI trigger type */
|
2007-02-02 23:48:22 +07:00
|
|
|
acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt,
|
2007-02-02 23:48:22 +07:00
|
|
|
(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
|
|
|
/*
|
2007-02-02 23:48:22 +07:00
|
|
|
* now that acpi_gbl_FADT is initialized,
|
2005-04-17 05:20:36 +07:00
|
|
|
* update it with result from INT_SRC_OVR parsing
|
|
|
|
*/
|
2007-02-02 23:48:22 +07:00
|
|
|
acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
status =
|
|
|
|
acpi_enable_subsystem(~
|
|
|
|
(ACPI_NO_HARDWARE_INIT |
|
|
|
|
ACPI_NO_ACPI_ENABLE));
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
|
|
|
|
goto error0;
|
|
|
|
}
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
error0:
|
2005-04-17 05:20:36 +07:00
|
|
|
disable_acpi();
|
2006-06-27 11:41:40 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int __init acpi_bus_init(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
int result = 0;
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
extern acpi_status acpi_os_initialize1(void);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-03-05 02:55:27 +07:00
|
|
|
acpi_os_initialize1();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
status =
|
|
|
|
acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2005-08-05 11:44:28 +07:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Unable to start the ACPI Interpreter\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
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).
|
|
|
|
*
|
2007-02-10 13:32:16 +07:00
|
|
|
* This is accomplished by looking for the ECDT table, and getting
|
2005-04-17 05:20:36 +07:00
|
|
|
* the EC parameters out of that.
|
|
|
|
*/
|
|
|
|
status = acpi_ec_ecdt_probe();
|
|
|
|
/* Ignore result. Not having an ECDT is not fatal. */
|
|
|
|
|
2009-10-29 10:05:05 +07:00
|
|
|
acpi_bus_osc_support();
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
|
|
|
|
goto error1;
|
|
|
|
}
|
|
|
|
|
2010-10-26 09:06:54 +07:00
|
|
|
/*
|
|
|
|
* _PDC control method may load dynamic SSDT tables,
|
|
|
|
* and we need to install the table handler before that.
|
|
|
|
*/
|
|
|
|
acpi_sysfs_init();
|
|
|
|
|
2009-12-21 02:19:09 +07:00
|
|
|
acpi_early_processor_set_pdc();
|
|
|
|
|
2008-10-06 09:31:36 +07:00
|
|
|
/*
|
|
|
|
* 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();
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
printk(KERN_INFO PREFIX "Interpreter enabled\n");
|
|
|
|
|
2007-02-10 13:32:16 +07:00
|
|
|
/* Initialize sleep structures */
|
|
|
|
acpi_sleep_init();
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* 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 11:44:28 +07:00
|
|
|
status =
|
|
|
|
acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
|
|
|
|
&acpi_bus_notify, NULL);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2005-08-05 11:44:28 +07:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Unable to register for device notifications\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
goto error1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create the top ACPI proc directory
|
|
|
|
*/
|
|
|
|
acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Mimic structured exception handling */
|
2005-08-05 11:44:28 +07:00
|
|
|
error1:
|
2005-04-17 05:20:36 +07:00
|
|
|
acpi_terminate();
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-11-03 06:19:59 +07:00
|
|
|
struct kobject *acpi_kobj;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int __init acpi_init(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
int result = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (acpi_disabled) {
|
|
|
|
printk(KERN_INFO PREFIX "Interpreter disabled.\n");
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-11-06 04:16:15 +07:00
|
|
|
acpi_kobj = kobject_create_and_add("acpi", firmware_kobj);
|
2007-11-03 06:19:59 +07:00
|
|
|
if (!acpi_kobj) {
|
2008-03-06 09:24:51 +07:00
|
|
|
printk(KERN_WARNING "%s: kset create error\n", __func__);
|
2007-11-03 06:19:59 +07:00
|
|
|
acpi_kobj = NULL;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-03-25 05:50:09 +07:00
|
|
|
init_acpi_device_notify();
|
2005-04-17 05:20:36 +07:00
|
|
|
result = acpi_bus_init();
|
|
|
|
|
|
|
|
if (!result) {
|
2008-02-15 16:27:20 +07:00
|
|
|
pci_mmcfg_late_init();
|
2011-02-11 06:04:52 +07:00
|
|
|
if (pm_apm_enabled()) {
|
2005-08-05 11:44:28 +07:00
|
|
|
printk(KERN_INFO PREFIX
|
|
|
|
"APM is already active, exiting\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
disable_acpi();
|
|
|
|
result = -ENODEV;
|
2011-02-11 06:04:52 +07:00
|
|
|
} else {
|
|
|
|
pm_set_acpi_flag();
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
} else
|
|
|
|
disable_acpi();
|
2009-03-25 05:49:38 +07:00
|
|
|
|
|
|
|
if (acpi_disabled)
|
|
|
|
return result;
|
|
|
|
|
2009-03-25 05:49:43 +07:00
|
|
|
acpi_scan_init();
|
2009-03-25 05:49:48 +07:00
|
|
|
acpi_ec_init();
|
2010-07-15 09:46:15 +07:00
|
|
|
acpi_debugfs_init();
|
2009-03-25 05:50:14 +07:00
|
|
|
acpi_sleep_proc_init();
|
2009-03-25 05:50:19 +07:00
|
|
|
acpi_wakeup_device_init();
|
2006-06-27 11:41:40 +07:00
|
|
|
return result;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
subsys_initcall(acpi_init);
|