2005-04-16 16:20:36 -06: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.
|
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/ioport.h>
|
2006-07-11 23:47:00 -06:00
|
|
|
#include <linux/kernel.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/pm.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/proc_fs.h>
|
2008-02-09 15: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 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2014-01-26 17:32:14 -07:00
|
|
|
#include <linux/regulator/machine.h>
|
2016-06-23 12:24:26 -06:00
|
|
|
#include <linux/workqueue.h>
|
|
|
|
#include <linux/reboot.h>
|
|
|
|
#include <linux/delay.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_X86
|
|
|
|
#include <asm/mpspec.h>
|
|
|
|
#endif
|
2016-09-12 12:54:20 -06:00
|
|
|
#include <linux/acpi_iort.h>
|
2008-02-15 02:27:20 -07:00
|
|
|
#include <linux/pci.h>
|
2011-07-12 23:14:20 -06:00
|
|
|
#include <acpi/apei.h>
|
2009-07-06 21:40:19 -06:00
|
|
|
#include <linux/dmi.h>
|
2011-02-10 16:04:52 -07:00
|
|
|
#include <linux/suspend.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-13 12:08:26 -06:00
|
|
|
#include "internal.h"
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#define _COMPONENT ACPI_BUS_COMPONENT
|
2007-02-12 20:42:12 -07:00
|
|
|
ACPI_MODULE_NAME("bus");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_device *acpi_root;
|
|
|
|
struct proc_dir_entry *acpi_root_dir;
|
2005-04-16 16:20:36 -06:00
|
|
|
EXPORT_SYMBOL(acpi_root_dir);
|
|
|
|
|
2010-05-11 19:26:48 -06:00
|
|
|
#ifdef CONFIG_X86
|
2014-05-12 01:50:16 -06:00
|
|
|
#ifdef CONFIG_ACPI_CUSTOM_DSDT
|
|
|
|
static inline int set_copy_dsdt(const struct dmi_system_id *id)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else
|
2010-04-08 00:34:27 -06: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;
|
|
|
|
}
|
2014-05-12 01:50:16 -06:00
|
|
|
#endif
|
2010-04-08 00:34:27 -06:00
|
|
|
|
|
|
|
static struct dmi_system_id dsdt_dmi_table[] __initdata = {
|
|
|
|
/*
|
2010-09-28 20:57:02 -06:00
|
|
|
* Invoke DSDT corruption work-around on all Toshiba Satellite.
|
2010-04-08 00:34:27 -06:00
|
|
|
* https://bugzilla.kernel.org/show_bug.cgi?id=14679
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
.callback = set_copy_dsdt,
|
2010-09-28 20:57:02 -06:00
|
|
|
.ident = "TOSHIBA Satellite",
|
2010-04-08 00:34:27 -06:00
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
|
2010-09-28 20:57:02 -06:00
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"),
|
2010-04-08 00:34:27 -06:00
|
|
|
},
|
2010-05-11 19:26:48 -06:00
|
|
|
},
|
|
|
|
{}
|
2010-04-08 00:34:27 -06:00
|
|
|
};
|
2010-05-11 19:26:48 -06:00
|
|
|
#else
|
|
|
|
static struct dmi_system_id dsdt_dmi_table[] __initdata = {
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
#endif
|
2010-04-08 00:34:27 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Device Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2009-09-21 13:30:01 -06:00
|
|
|
acpi_status acpi_bus_get_status_handle(acpi_handle handle,
|
|
|
|
unsigned long long *sta)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-09-21 13:30:01 -06:00
|
|
|
acpi_status status;
|
2005-08-04 22:44:28 -06:00
|
|
|
|
2009-09-21 13:30:01 -06:00
|
|
|
status = acpi_evaluate_integer(handle, "_STA", NULL, sta);
|
|
|
|
if (ACPI_SUCCESS(status))
|
|
|
|
return AE_OK;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-21 13:30:01 -06: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-16 16:20:36 -06:00
|
|
|
}
|
2009-09-21 13:30:01 -06:00
|
|
|
return status;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-21 13:30:01 -06:00
|
|
|
int acpi_bus_get_status(struct acpi_device *device)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
unsigned long long sta;
|
|
|
|
|
2017-04-21 04:47:40 -06:00
|
|
|
if (acpi_device_always_present(device)) {
|
|
|
|
acpi_set_device_status(device, ACPI_STA_DEFAULT);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-21 13:30:01 -06:00
|
|
|
status = acpi_bus_get_status_handle(device->handle, &sta);
|
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2013-11-22 13:56:06 -07:00
|
|
|
acpi_set_device_status(device, sta);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (device->status.functional && !device->status.present) {
|
2008-08-10 23:40:22 -06:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]: "
|
|
|
|
"functional but not present;\n",
|
2013-11-22 13:56:06 -07:00
|
|
|
device->pnp.bus_id, (u32)sta));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
|
2013-11-22 13:56:06 -07:00
|
|
|
device->pnp.bus_id, (u32)sta));
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2005-08-04 22:44:28 -06:00
|
|
|
EXPORT_SYMBOL(acpi_bus_get_status);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-17 00:51:21 -07:00
|
|
|
void acpi_bus_private_data_handler(acpi_handle handle,
|
2009-06-28 23:43:27 -06:00
|
|
|
void *context)
|
2008-01-17 00:51:21 -07:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_bus_private_data_handler);
|
|
|
|
|
2014-05-20 06:59:21 -06:00
|
|
|
int acpi_bus_attach_private_data(acpi_handle handle, void *data)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
status = acpi_attach_data(handle,
|
|
|
|
acpi_bus_private_data_handler, data);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
acpi_handle_debug(handle, "Error attaching device data\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(acpi_bus_attach_private_data);
|
|
|
|
|
2008-01-17 00:51:21 -07:00
|
|
|
int acpi_bus_get_private_data(acpi_handle handle, void **data)
|
|
|
|
{
|
2013-06-03 12:20:24 -06:00
|
|
|
acpi_status status;
|
2008-01-17 00:51:21 -07:00
|
|
|
|
|
|
|
if (!*data)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
status = acpi_get_data(handle, acpi_bus_private_data_handler, data);
|
2014-05-20 06:59:21 -06:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
acpi_handle_debug(handle, "No context for object\n");
|
2008-01-17 00:51:21 -07:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2014-05-20 06:59:21 -06:00
|
|
|
EXPORT_SYMBOL_GPL(acpi_bus_get_private_data);
|
|
|
|
|
|
|
|
void acpi_bus_detach_private_data(acpi_handle handle)
|
|
|
|
{
|
|
|
|
acpi_detach_data(handle, acpi_bus_private_data_handler);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(acpi_bus_detach_private_data);
|
2008-01-17 00:51:21 -07:00
|
|
|
|
2009-10-28 21:04:28 -06:00
|
|
|
static void acpi_print_osc_error(acpi_handle handle,
|
2016-06-16 09:23:09 -06:00
|
|
|
struct acpi_osc_context *context, char *error)
|
2009-10-28 21:04:28 -06:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2016-06-16 09:23:09 -06:00
|
|
|
acpi_handle_debug(handle, "(%s): %s\n", context->uuid_str, error);
|
|
|
|
|
|
|
|
pr_debug("_OSC request data:");
|
2009-10-28 21:04:28 -06:00
|
|
|
for (i = 0; i < context->cap.length; i += sizeof(u32))
|
2016-06-16 09:23:09 -06:00
|
|
|
pr_debug(" %x", *((u32 *)(context->cap.pointer + i)));
|
|
|
|
|
|
|
|
pr_debug("\n");
|
2009-10-28 21:04:28 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2017-06-05 10:40:44 -06:00
|
|
|
guid_t guid;
|
2009-10-28 21:04:28 -06:00
|
|
|
u32 errors;
|
2009-12-23 02:04:11 -07:00
|
|
|
struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
|
2009-10-28 21:04:28 -06:00
|
|
|
|
|
|
|
if (!context)
|
|
|
|
return AE_ERROR;
|
2017-06-05 10:40:44 -06:00
|
|
|
if (guid_parse(context->uuid_str, &guid))
|
2009-10-28 21:04:28 -06:00
|
|
|
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;
|
2017-06-05 10:40:44 -06:00
|
|
|
in_params[0].buffer.pointer = (u8 *)&guid;
|
2009-10-28 21:04:28 -06:00
|
|
|
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 02:04:11 -07:00
|
|
|
status = acpi_evaluate_object(handle, "_OSC", &input, &output);
|
2009-10-28 21:04:28 -06:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return status;
|
|
|
|
|
2009-12-23 02:04:11 -07:00
|
|
|
if (!output.length)
|
2009-10-28 21:04:28 -06:00
|
|
|
return AE_NULL_OBJECT;
|
|
|
|
|
2009-12-23 02:04:11 -07:00
|
|
|
out_obj = output.pointer;
|
|
|
|
if (out_obj->type != ACPI_TYPE_BUFFER
|
|
|
|
|| out_obj->buffer.length != context->cap.length) {
|
2009-10-28 21:04:28 -06: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) {
|
2013-09-05 15:05:54 -06:00
|
|
|
if (((u32 *)context->cap.pointer)[OSC_QUERY_DWORD]
|
2009-10-28 21:04:28 -06:00
|
|
|
& OSC_QUERY_ENABLE)
|
|
|
|
goto out_success;
|
|
|
|
status = AE_SUPPORT;
|
|
|
|
goto out_kfree;
|
|
|
|
}
|
|
|
|
status = AE_ERROR;
|
|
|
|
goto out_kfree;
|
|
|
|
}
|
|
|
|
out_success:
|
2009-12-23 02:04:11 -07:00
|
|
|
context->ret.length = out_obj->buffer.length;
|
2013-03-11 02:20:16 -06:00
|
|
|
context->ret.pointer = kmemdup(out_obj->buffer.pointer,
|
|
|
|
context->ret.length, GFP_KERNEL);
|
2009-12-23 02:04:11 -07:00
|
|
|
if (!context->ret.pointer) {
|
|
|
|
status = AE_NO_MEMORY;
|
|
|
|
goto out_kfree;
|
|
|
|
}
|
|
|
|
status = AE_OK;
|
2009-10-28 21:04:28 -06:00
|
|
|
|
|
|
|
out_kfree:
|
2009-12-23 02:04:11 -07:00
|
|
|
kfree(output.pointer);
|
|
|
|
if (status != AE_OK)
|
|
|
|
context->ret.pointer = NULL;
|
2009-10-28 21:04:28 -06:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_run_osc);
|
|
|
|
|
2011-07-12 23:14:20 -06:00
|
|
|
bool osc_sb_apei_support_acked;
|
2016-07-21 10:18:07 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ACPI 6.0 Section 8.4.4.2 Idle State Coordination
|
|
|
|
* OSPM supports platform coordinated low power idle(LPI) states
|
|
|
|
*/
|
|
|
|
bool osc_pc_lpi_support_confirmed;
|
|
|
|
EXPORT_SYMBOL_GPL(osc_pc_lpi_support_confirmed);
|
|
|
|
|
2009-10-28 21:05:05 -06: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;
|
|
|
|
|
2013-09-05 15:05:54 -06:00
|
|
|
capbuf[OSC_QUERY_DWORD] = OSC_QUERY_ENABLE;
|
|
|
|
capbuf[OSC_SUPPORT_DWORD] = OSC_SB_PR3_SUPPORT; /* _PR3 is in use */
|
2015-09-14 09:01:55 -06:00
|
|
|
if (IS_ENABLED(CONFIG_ACPI_PROCESSOR_AGGREGATOR))
|
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PAD_SUPPORT;
|
|
|
|
if (IS_ENABLED(CONFIG_ACPI_PROCESSOR))
|
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PPC_OST_SUPPORT;
|
2011-07-12 23:14:20 -06:00
|
|
|
|
2013-09-05 15:05:54 -06:00
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_HOTPLUG_OST_SUPPORT;
|
2016-07-21 10:18:07 -06:00
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PCLPI_SUPPORT;
|
2012-05-23 20:25:24 -06:00
|
|
|
|
2016-11-22 13:23:58 -07:00
|
|
|
#ifdef CONFIG_X86
|
|
|
|
if (boot_cpu_has(X86_FEATURE_HWP)) {
|
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_CPC_SUPPORT;
|
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_CPCV2_SUPPORT;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-11-29 11:43:27 -07:00
|
|
|
if (IS_ENABLED(CONFIG_SCHED_MC_PRIO))
|
2016-11-22 13:23:59 -07:00
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_CPC_DIVERSE_HIGH_SUPPORT;
|
|
|
|
|
2011-07-12 23:14:20 -06:00
|
|
|
if (!ghes_disable)
|
2013-09-05 15:05:54 -06:00
|
|
|
capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_APEI_SUPPORT;
|
2009-10-28 21:05:05 -06:00
|
|
|
if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
|
|
|
|
return;
|
2011-07-12 23:14:20 -06:00
|
|
|
if (ACPI_SUCCESS(acpi_run_osc(handle, &context))) {
|
|
|
|
u32 *capbuf_ret = context.ret.pointer;
|
2016-07-21 10:18:07 -06:00
|
|
|
if (context.ret.length > OSC_SUPPORT_DWORD) {
|
2011-07-12 23:14:20 -06:00
|
|
|
osc_sb_apei_support_acked =
|
2013-09-05 15:05:54 -06:00
|
|
|
capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_APEI_SUPPORT;
|
2016-07-21 10:18:07 -06:00
|
|
|
osc_pc_lpi_support_confirmed =
|
|
|
|
capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_PCLPI_SUPPORT;
|
|
|
|
}
|
2009-10-28 21:05:05 -06:00
|
|
|
kfree(context.ret.pointer);
|
2011-07-12 23:14:20 -06:00
|
|
|
}
|
|
|
|
/* do we need to check other returned cap? Sounds no */
|
2009-10-28 21:05:05 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Notification Handling
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_bus_notify
|
|
|
|
* ---------------
|
|
|
|
* Callback for all 'system-level' device notifications (values 0x00-0x7F).
|
|
|
|
*/
|
2005-08-04 22:44:28 -06:00
|
|
|
static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-02-06 05:58:13 -07:00
|
|
|
struct acpi_device *adev;
|
2009-04-30 09:35:37 -06:00
|
|
|
struct acpi_driver *driver;
|
2014-02-06 05:58:13 -07:00
|
|
|
u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
|
2014-04-30 17:16:06 -06:00
|
|
|
bool hotplug_event = false;
|
2009-05-22 11:43:41 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (type) {
|
|
|
|
case ACPI_NOTIFY_BUS_CHECK:
|
2014-02-06 05:58:13 -07:00
|
|
|
acpi_handle_debug(handle, "ACPI_NOTIFY_BUS_CHECK event\n");
|
2014-04-30 17:16:06 -06:00
|
|
|
hotplug_event = true;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_DEVICE_CHECK:
|
2014-02-06 05:58:13 -07:00
|
|
|
acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_CHECK event\n");
|
2014-04-30 17:16:06 -06:00
|
|
|
hotplug_event = true;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_DEVICE_WAKE:
|
2014-02-06 05:58:13 -07:00
|
|
|
acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_WAKE event\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_EJECT_REQUEST:
|
2014-02-06 05:58:13 -07:00
|
|
|
acpi_handle_debug(handle, "ACPI_NOTIFY_EJECT_REQUEST event\n");
|
2014-04-30 17:16:06 -06:00
|
|
|
hotplug_event = true;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
|
2014-02-06 05:58:13 -07:00
|
|
|
acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_CHECK_LIGHT event\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
/* TBD: Exactly what does 'light' mean? */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_FREQUENCY_MISMATCH:
|
2014-02-06 05:58:13 -07:00
|
|
|
acpi_handle_err(handle, "Device cannot be configured due "
|
|
|
|
"to a frequency mismatch\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_BUS_MODE_MISMATCH:
|
2014-02-06 05:58:13 -07:00
|
|
|
acpi_handle_err(handle, "Device cannot be configured due "
|
|
|
|
"to a bus mode mismatch\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ACPI_NOTIFY_POWER_FAULT:
|
2014-02-06 05:58:13 -07:00
|
|
|
acpi_handle_err(handle, "Device has suffered a power fault\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2014-04-24 11:27:49 -06:00
|
|
|
acpi_handle_debug(handle, "Unknown event type 0x%x\n", type);
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2014-02-06 05:58:13 -07:00
|
|
|
adev = acpi_bus_get_acpi_device(handle);
|
|
|
|
if (!adev)
|
|
|
|
goto err;
|
2014-02-03 16:43:05 -07:00
|
|
|
|
2014-02-06 05:58:13 -07:00
|
|
|
driver = adev->driver;
|
|
|
|
if (driver && driver->ops.notify &&
|
|
|
|
(driver->flags & ACPI_DRIVER_ALL_NOTIFY_EVENTS))
|
|
|
|
driver->ops.notify(adev, type);
|
|
|
|
|
2017-06-30 01:25:38 -06:00
|
|
|
if (!hotplug_event) {
|
|
|
|
acpi_bus_put_acpi_device(adev);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ACPI_SUCCESS(acpi_hotplug_schedule(adev, type)))
|
2014-04-30 17:16:06 -06:00
|
|
|
return;
|
|
|
|
|
2014-02-06 05:58:13 -07:00
|
|
|
acpi_bus_put_acpi_device(adev);
|
|
|
|
|
|
|
|
err:
|
2014-02-20 17:07:17 -07:00
|
|
|
acpi_evaluate_ost(handle, type, ost_code, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2015-07-17 14:54:01 -06:00
|
|
|
static void acpi_device_notify(acpi_handle handle, u32 event, void *data)
|
|
|
|
{
|
|
|
|
struct acpi_device *device = data;
|
|
|
|
|
|
|
|
device->driver->ops.notify(device, event);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acpi_device_notify_fixed(void *data)
|
|
|
|
{
|
|
|
|
struct acpi_device *device = data;
|
|
|
|
|
|
|
|
/* Fixed hardware devices have no handles */
|
|
|
|
acpi_device_notify(NULL, ACPI_FIXED_HARDWARE_EVENT, device);
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 acpi_device_fixed_event(void *data)
|
|
|
|
{
|
|
|
|
acpi_os_execute(OSL_NOTIFY_HANDLER, acpi_device_notify_fixed, data);
|
|
|
|
return ACPI_INTERRUPT_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_device_install_notify_handler(struct acpi_device *device)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
|
|
|
|
status =
|
|
|
|
acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
|
|
|
|
acpi_device_fixed_event,
|
|
|
|
device);
|
|
|
|
else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
|
|
|
|
status =
|
|
|
|
acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
|
|
|
|
acpi_device_fixed_event,
|
|
|
|
device);
|
|
|
|
else
|
|
|
|
status = acpi_install_notify_handler(device->handle,
|
|
|
|
ACPI_DEVICE_NOTIFY,
|
|
|
|
acpi_device_notify,
|
|
|
|
device);
|
|
|
|
|
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acpi_device_remove_notify_handler(struct acpi_device *device)
|
|
|
|
{
|
|
|
|
if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
|
|
|
|
acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
|
|
|
|
acpi_device_fixed_event);
|
|
|
|
else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
|
|
|
|
acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
|
|
|
|
acpi_device_fixed_event);
|
|
|
|
else
|
|
|
|
acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
|
|
|
|
acpi_device_notify);
|
|
|
|
}
|
|
|
|
|
2016-06-23 12:24:26 -06:00
|
|
|
/* Handle events targeting \_SB device (at present only graceful shutdown) */
|
|
|
|
|
|
|
|
#define ACPI_SB_NOTIFY_SHUTDOWN_REQUEST 0x81
|
|
|
|
#define ACPI_SB_INDICATE_INTERVAL 10000
|
|
|
|
|
|
|
|
static void sb_notify_work(struct work_struct *dummy)
|
|
|
|
{
|
|
|
|
acpi_handle sb_handle;
|
|
|
|
|
|
|
|
orderly_poweroff(true);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* After initiating graceful shutdown, the ACPI spec requires OSPM
|
|
|
|
* to evaluate _OST method once every 10seconds to indicate that
|
|
|
|
* the shutdown is in progress
|
|
|
|
*/
|
|
|
|
acpi_get_handle(NULL, "\\_SB", &sb_handle);
|
|
|
|
while (1) {
|
|
|
|
pr_info("Graceful shutdown in progress.\n");
|
|
|
|
acpi_evaluate_ost(sb_handle, ACPI_OST_EC_OSPM_SHUTDOWN,
|
|
|
|
ACPI_OST_SC_OS_SHUTDOWN_IN_PROGRESS, NULL);
|
|
|
|
msleep(ACPI_SB_INDICATE_INTERVAL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acpi_sb_notify(acpi_handle handle, u32 event, void *data)
|
|
|
|
{
|
|
|
|
static DECLARE_WORK(acpi_sb_work, sb_notify_work);
|
|
|
|
|
|
|
|
if (event == ACPI_SB_NOTIFY_SHUTDOWN_REQUEST) {
|
|
|
|
if (!work_busy(&acpi_sb_work))
|
|
|
|
schedule_work(&acpi_sb_work);
|
|
|
|
} else
|
|
|
|
pr_warn("event %x is not supported by \\_SB device\n", event);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init acpi_setup_sb_notify_handler(void)
|
|
|
|
{
|
|
|
|
acpi_handle sb_handle;
|
|
|
|
|
|
|
|
if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &sb_handle)))
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
if (ACPI_FAILURE(acpi_install_notify_handler(sb_handle, ACPI_DEVICE_NOTIFY,
|
|
|
|
acpi_sb_notify, NULL)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-17 14:53:52 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Device Matching
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2016-02-16 05:52:38 -07:00
|
|
|
/**
|
|
|
|
* acpi_get_first_physical_node - Get first physical node of an ACPI device
|
|
|
|
* @adev: ACPI device in question
|
|
|
|
*
|
|
|
|
* Return: First physical node of ACPI device @adev
|
|
|
|
*/
|
|
|
|
struct device *acpi_get_first_physical_node(struct acpi_device *adev)
|
2015-07-31 18:39:43 -06:00
|
|
|
{
|
|
|
|
struct mutex *physical_node_lock = &adev->physical_node_lock;
|
2016-02-16 05:52:38 -07:00
|
|
|
struct device *phys_dev;
|
2015-07-31 18:39:43 -06:00
|
|
|
|
|
|
|
mutex_lock(physical_node_lock);
|
|
|
|
if (list_empty(&adev->physical_node_list)) {
|
2016-02-16 05:52:38 -07:00
|
|
|
phys_dev = NULL;
|
2015-07-31 18:39:43 -06:00
|
|
|
} else {
|
|
|
|
const struct acpi_device_physical_node *node;
|
|
|
|
|
|
|
|
node = list_first_entry(&adev->physical_node_list,
|
|
|
|
struct acpi_device_physical_node, node);
|
2016-02-16 05:52:38 -07:00
|
|
|
|
|
|
|
phys_dev = node->dev;
|
2015-07-31 18:39:43 -06:00
|
|
|
}
|
|
|
|
mutex_unlock(physical_node_lock);
|
2016-02-16 05:52:38 -07:00
|
|
|
return phys_dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct acpi_device *acpi_primary_dev_companion(struct acpi_device *adev,
|
|
|
|
const struct device *dev)
|
|
|
|
{
|
|
|
|
const struct device *phys_dev = acpi_get_first_physical_node(adev);
|
|
|
|
|
|
|
|
return phys_dev && phys_dev == dev ? adev : NULL;
|
2015-07-31 18:39:43 -06:00
|
|
|
}
|
|
|
|
|
2015-07-29 15:57:51 -06:00
|
|
|
/**
|
|
|
|
* acpi_device_is_first_physical_node - Is given dev first physical node
|
|
|
|
* @adev: ACPI companion device
|
|
|
|
* @dev: Physical device to check
|
|
|
|
*
|
|
|
|
* Function checks if given @dev is the first physical devices attached to
|
|
|
|
* the ACPI companion device. This distinction is needed in some cases
|
|
|
|
* where the same companion device is shared between many physical devices.
|
|
|
|
*
|
|
|
|
* Note that the caller have to provide valid @adev pointer.
|
|
|
|
*/
|
|
|
|
bool acpi_device_is_first_physical_node(struct acpi_device *adev,
|
|
|
|
const struct device *dev)
|
|
|
|
{
|
2015-07-31 18:39:43 -06:00
|
|
|
return !!acpi_primary_dev_companion(adev, dev);
|
2015-07-29 15:57:51 -06:00
|
|
|
}
|
|
|
|
|
2015-07-17 14:53:52 -06:00
|
|
|
/*
|
|
|
|
* acpi_companion_match() - Can we match via ACPI companion device
|
|
|
|
* @dev: Device in question
|
|
|
|
*
|
|
|
|
* Check if the given device has an ACPI companion and if that companion has
|
|
|
|
* a valid list of PNP IDs, and if the device is the first (primary) physical
|
|
|
|
* device associated with it. Return the companion pointer if that's the case
|
|
|
|
* or NULL otherwise.
|
|
|
|
*
|
|
|
|
* If multiple physical devices are attached to a single ACPI companion, we need
|
|
|
|
* to be careful. The usage scenario for this kind of relationship is that all
|
|
|
|
* of the physical devices in question use resources provided by the ACPI
|
|
|
|
* companion. A typical case is an MFD device where all the sub-devices share
|
|
|
|
* the parent's ACPI companion. In such cases we can only allow the primary
|
|
|
|
* (first) physical device to be matched with the help of the companion's PNP
|
|
|
|
* IDs.
|
|
|
|
*
|
|
|
|
* Additional physical devices sharing the ACPI companion can still use
|
|
|
|
* resources available from it but they will be matched normally using functions
|
|
|
|
* provided by their bus types (and analogously for their modalias).
|
|
|
|
*/
|
|
|
|
struct acpi_device *acpi_companion_match(const struct device *dev)
|
|
|
|
{
|
|
|
|
struct acpi_device *adev;
|
|
|
|
|
|
|
|
adev = ACPI_COMPANION(dev);
|
|
|
|
if (!adev)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (list_empty(&adev->pnp.ids))
|
|
|
|
return NULL;
|
|
|
|
|
2015-07-31 18:39:43 -06:00
|
|
|
return acpi_primary_dev_companion(adev, dev);
|
2015-07-17 14:53:52 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_of_match_device - Match device object using the "compatible" property.
|
|
|
|
* @adev: ACPI device object to match.
|
|
|
|
* @of_match_table: List of device IDs to match against.
|
|
|
|
*
|
|
|
|
* If @dev has an ACPI companion which has ACPI_DT_NAMESPACE_HID in its list of
|
|
|
|
* identifiers and a _DSD object with the "compatible" property, use that
|
|
|
|
* property to match against the given list of identifiers.
|
|
|
|
*/
|
|
|
|
static bool acpi_of_match_device(struct acpi_device *adev,
|
|
|
|
const struct of_device_id *of_match_table)
|
|
|
|
{
|
|
|
|
const union acpi_object *of_compatible, *obj;
|
|
|
|
int i, nval;
|
|
|
|
|
|
|
|
if (!adev)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
of_compatible = adev->data.of_compatible;
|
|
|
|
if (!of_match_table || !of_compatible)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (of_compatible->type == ACPI_TYPE_PACKAGE) {
|
|
|
|
nval = of_compatible->package.count;
|
|
|
|
obj = of_compatible->package.elements;
|
|
|
|
} else { /* Must be ACPI_TYPE_STRING. */
|
|
|
|
nval = 1;
|
|
|
|
obj = of_compatible;
|
|
|
|
}
|
|
|
|
/* Now we can look for the driver DT compatible strings */
|
|
|
|
for (i = 0; i < nval; i++, obj++) {
|
|
|
|
const struct of_device_id *id;
|
|
|
|
|
|
|
|
for (id = of_match_table; id->compatible[0]; id++)
|
|
|
|
if (!strcasecmp(obj->string.pointer, id->compatible))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-02-05 09:30:12 -07:00
|
|
|
static bool acpi_of_modalias(struct acpi_device *adev,
|
|
|
|
char *modalias, size_t len)
|
|
|
|
{
|
|
|
|
const union acpi_object *of_compatible;
|
|
|
|
const union acpi_object *obj;
|
|
|
|
const char *str, *chr;
|
|
|
|
|
|
|
|
of_compatible = adev->data.of_compatible;
|
|
|
|
if (!of_compatible)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (of_compatible->type == ACPI_TYPE_PACKAGE)
|
|
|
|
obj = of_compatible->package.elements;
|
|
|
|
else /* Must be ACPI_TYPE_STRING. */
|
|
|
|
obj = of_compatible;
|
|
|
|
|
|
|
|
str = obj->string.pointer;
|
|
|
|
chr = strchr(str, ',');
|
|
|
|
strlcpy(modalias, chr ? chr + 1 : str, len);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_set_modalias - Set modalias using "compatible" property or supplied ID
|
|
|
|
* @adev: ACPI device object to match
|
|
|
|
* @default_id: ID string to use as default if no compatible string found
|
|
|
|
* @modalias: Pointer to buffer that modalias value will be copied into
|
|
|
|
* @len: Length of modalias buffer
|
|
|
|
*
|
|
|
|
* This is a counterpart of of_modalias_node() for struct acpi_device objects.
|
|
|
|
* If there is a compatible string for @adev, it will be copied to @modalias
|
|
|
|
* with the vendor prefix stripped; otherwise, @default_id will be used.
|
|
|
|
*/
|
|
|
|
void acpi_set_modalias(struct acpi_device *adev, const char *default_id,
|
|
|
|
char *modalias, size_t len)
|
|
|
|
{
|
|
|
|
if (!acpi_of_modalias(adev, modalias, len))
|
|
|
|
strlcpy(modalias, default_id, len);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(acpi_set_modalias);
|
|
|
|
|
2015-07-17 14:53:52 -06:00
|
|
|
static bool __acpi_match_device_cls(const struct acpi_device_id *id,
|
|
|
|
struct acpi_hardware_id *hwid)
|
|
|
|
{
|
|
|
|
int i, msk, byte_shift;
|
|
|
|
char buf[3];
|
|
|
|
|
|
|
|
if (!id->cls)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* Apply class-code bitmask, before checking each class-code byte */
|
|
|
|
for (i = 1; i <= 3; i++) {
|
|
|
|
byte_shift = 8 * (3 - i);
|
|
|
|
msk = (id->cls_msk >> byte_shift) & 0xFF;
|
|
|
|
if (!msk)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
sprintf(buf, "%02x", (id->cls >> byte_shift) & msk);
|
|
|
|
if (strncmp(buf, &hwid->id[(i - 1) * 2], 2))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct acpi_device_id *__acpi_match_device(
|
|
|
|
struct acpi_device *device,
|
|
|
|
const struct acpi_device_id *ids,
|
|
|
|
const struct of_device_id *of_ids)
|
|
|
|
{
|
|
|
|
const struct acpi_device_id *id;
|
|
|
|
struct acpi_hardware_id *hwid;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the device is not present, it is unnecessary to load device
|
|
|
|
* driver for it.
|
|
|
|
*/
|
|
|
|
if (!device || !device->status.present)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
list_for_each_entry(hwid, &device->pnp.ids, list) {
|
|
|
|
/* First, check the ACPI/PNP IDs provided by the caller. */
|
|
|
|
for (id = ids; id->id[0] || id->cls; id++) {
|
|
|
|
if (id->id[0] && !strcmp((char *) id->id, hwid->id))
|
|
|
|
return id;
|
|
|
|
else if (id->cls && __acpi_match_device_cls(id, hwid))
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Next, check ACPI_DT_NAMESPACE_HID and try to match the
|
|
|
|
* "compatible" property if found.
|
|
|
|
*
|
|
|
|
* The id returned by the below is not valid, but the only
|
|
|
|
* caller passing non-NULL of_ids here is only interested in
|
|
|
|
* whether or not the return value is NULL.
|
|
|
|
*/
|
|
|
|
if (!strcmp(ACPI_DT_NAMESPACE_HID, hwid->id)
|
|
|
|
&& acpi_of_match_device(device, of_ids))
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_match_device - Match a struct device against a given list of ACPI IDs
|
|
|
|
* @ids: Array of struct acpi_device_id object to match against.
|
|
|
|
* @dev: The device structure to match.
|
|
|
|
*
|
|
|
|
* Check if @dev has a valid ACPI handle and if there is a struct acpi_device
|
|
|
|
* object for that handle and use that object to match against a given list of
|
|
|
|
* device IDs.
|
|
|
|
*
|
|
|
|
* Return a pointer to the first matching ID on success or %NULL on failure.
|
|
|
|
*/
|
|
|
|
const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
|
|
|
|
const struct device *dev)
|
|
|
|
{
|
|
|
|
return __acpi_match_device(acpi_companion_match(dev), ids, NULL);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(acpi_match_device);
|
|
|
|
|
|
|
|
int acpi_match_device_ids(struct acpi_device *device,
|
|
|
|
const struct acpi_device_id *ids)
|
|
|
|
{
|
|
|
|
return __acpi_match_device(device, ids, NULL) ? 0 : -ENOENT;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_match_device_ids);
|
|
|
|
|
|
|
|
bool acpi_driver_match_device(struct device *dev,
|
|
|
|
const struct device_driver *drv)
|
|
|
|
{
|
|
|
|
if (!drv->acpi_match_table)
|
|
|
|
return acpi_of_match_device(ACPI_COMPANION(dev),
|
|
|
|
drv->of_match_table);
|
|
|
|
|
|
|
|
return !!__acpi_match_device(acpi_companion_match(dev),
|
|
|
|
drv->acpi_match_table, drv->of_match_table);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(acpi_driver_match_device);
|
|
|
|
|
2015-07-17 14:54:01 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
ACPI Driver Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_bus_register_driver - register a driver with the ACPI bus
|
|
|
|
* @driver: driver being registered
|
|
|
|
*
|
|
|
|
* Registers a driver with the ACPI bus. Searches the namespace for all
|
|
|
|
* devices that match the driver's criteria and binds. Returns zero for
|
|
|
|
* success or a negative error status for failure.
|
|
|
|
*/
|
|
|
|
int acpi_bus_register_driver(struct acpi_driver *driver)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (acpi_disabled)
|
|
|
|
return -ENODEV;
|
|
|
|
driver->drv.name = driver->name;
|
|
|
|
driver->drv.bus = &acpi_bus_type;
|
|
|
|
driver->drv.owner = driver->owner;
|
|
|
|
|
|
|
|
ret = driver_register(&driver->drv);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(acpi_bus_register_driver);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_bus_unregister_driver - unregisters a driver with the ACPI bus
|
|
|
|
* @driver: driver to unregister
|
|
|
|
*
|
|
|
|
* Unregisters a driver with the ACPI bus. Searches the namespace for all
|
|
|
|
* devices that match the driver's criteria and unbinds.
|
|
|
|
*/
|
|
|
|
void acpi_bus_unregister_driver(struct acpi_driver *driver)
|
|
|
|
{
|
|
|
|
driver_unregister(&driver->drv);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(acpi_bus_unregister_driver);
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
ACPI Bus operations
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static int acpi_bus_match(struct device *dev, struct device_driver *drv)
|
|
|
|
{
|
|
|
|
struct acpi_device *acpi_dev = to_acpi_device(dev);
|
|
|
|
struct acpi_driver *acpi_drv = to_acpi_driver(drv);
|
|
|
|
|
|
|
|
return acpi_dev->flags.match_driver
|
|
|
|
&& !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
|
|
|
|
{
|
|
|
|
return __acpi_device_uevent_modalias(to_acpi_device(dev), env);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_device_probe(struct device *dev)
|
|
|
|
{
|
|
|
|
struct acpi_device *acpi_dev = to_acpi_device(dev);
|
|
|
|
struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (acpi_dev->handler && !acpi_is_pnp_device(acpi_dev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!acpi_drv->ops.add)
|
|
|
|
return -ENOSYS;
|
|
|
|
|
|
|
|
ret = acpi_drv->ops.add(acpi_dev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
acpi_dev->driver = acpi_drv;
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Driver [%s] successfully bound to device [%s]\n",
|
|
|
|
acpi_drv->name, acpi_dev->pnp.bus_id));
|
|
|
|
|
|
|
|
if (acpi_drv->ops.notify) {
|
|
|
|
ret = acpi_device_install_notify_handler(acpi_dev);
|
|
|
|
if (ret) {
|
|
|
|
if (acpi_drv->ops.remove)
|
|
|
|
acpi_drv->ops.remove(acpi_dev);
|
|
|
|
|
|
|
|
acpi_dev->driver = NULL;
|
|
|
|
acpi_dev->driver_data = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found driver [%s] for device [%s]\n",
|
|
|
|
acpi_drv->name, acpi_dev->pnp.bus_id));
|
|
|
|
get_device(dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_device_remove(struct device * dev)
|
|
|
|
{
|
|
|
|
struct acpi_device *acpi_dev = to_acpi_device(dev);
|
|
|
|
struct acpi_driver *acpi_drv = acpi_dev->driver;
|
|
|
|
|
|
|
|
if (acpi_drv) {
|
|
|
|
if (acpi_drv->ops.notify)
|
|
|
|
acpi_device_remove_notify_handler(acpi_dev);
|
|
|
|
if (acpi_drv->ops.remove)
|
|
|
|
acpi_drv->ops.remove(acpi_dev);
|
|
|
|
}
|
|
|
|
acpi_dev->driver = NULL;
|
|
|
|
acpi_dev->driver_data = NULL;
|
|
|
|
|
|
|
|
put_device(dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct bus_type acpi_bus_type = {
|
|
|
|
.name = "acpi",
|
|
|
|
.match = acpi_bus_match,
|
|
|
|
.probe = acpi_device_probe,
|
|
|
|
.remove = acpi_device_remove,
|
|
|
|
.uevent = acpi_device_uevent,
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Initialization/Cleanup
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int __init acpi_bus_init_irq(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-06-03 12:20:24 -06:00
|
|
|
acpi_status status;
|
2005-08-04 22:44:28 -06:00
|
|
|
char *message = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
2007-02-09 23:32:16 -07:00
|
|
|
/*
|
2005-04-16 16:20:36 -06: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;
|
2015-03-24 08:02:48 -06:00
|
|
|
case ACPI_IRQ_MODEL_GIC:
|
|
|
|
message = "GIC";
|
|
|
|
break;
|
2006-12-22 10:50:04 -07:00
|
|
|
case ACPI_IRQ_MODEL_PLATFORM:
|
|
|
|
message = "platform specific model";
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
default:
|
|
|
|
printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message);
|
|
|
|
|
2013-06-28 10:24:39 -06:00
|
|
|
status = acpi_execute_simple_method(NULL, "\\_PIC", acpi_irq_model);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
|
2006-06-26 21:58:43 -06:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
ACPI / init: Switch over platform to the ACPI mode later
Commit 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before
timekeeping_init()" moved the ACPI subsystem initialization,
including the ACPI mode enabling, to an earlier point in the
initialization sequence, to allow the timekeeping subsystem
use ACPI early. Unfortunately, that resulted in boot regressions
on some systems and the early ACPI initialization was moved toward
its original position in the kernel initialization code by commit
c4e1acbb35e4 "ACPI / init: Invoke early ACPI initialization later".
However, that turns out to be insufficient, as boot is still broken
on the Tyan S8812 mainboard.
To fix that issue, split the ACPI early initialization code into
two pieces so the majority of it still located in acpi_early_init()
and the part switching over the platform into the ACPI mode goes into
a new function, acpi_subsystem_init(), executed at the original early
ACPI initialization spot.
That fixes the Tyan S8812 boot problem, but still allows ACPI
tables to be loaded earlier which is useful to the EFI code in
efi_enter_virtual_mode().
Link: https://bugzilla.kernel.org/show_bug.cgi?id=97141
Fixes: 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before timekeeping_init()"
Reported-and-tested-by: Marius Tolzmann <tolzmann@molgen.mpg.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Toshi Kani <toshi.kani@hp.com>
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Reviewed-by: Lee, Chun-Yi <jlee@suse.com>
2015-06-09 17:33:36 -06:00
|
|
|
/**
|
|
|
|
* acpi_early_init - Initialize ACPICA and populate the ACPI namespace.
|
|
|
|
*
|
|
|
|
* The ACPI tables are accessible after this, but the handling of events has not
|
|
|
|
* been initialized and the global lock is not available yet, so AML should not
|
|
|
|
* be executed at this point.
|
|
|
|
*
|
|
|
|
* Doing this before switching the EFI runtime services to virtual mode allows
|
|
|
|
* the EfiBootServices memory to be freed slightly earlier on boot.
|
|
|
|
*/
|
2005-08-04 22:44:28 -06:00
|
|
|
void __init acpi_early_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-06-03 12:20:24 -06:00
|
|
|
acpi_status status;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (acpi_disabled)
|
2006-06-26 22:41:40 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-03-17 14:44:00 -07:00
|
|
|
printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION);
|
|
|
|
|
2014-05-30 18:15:02 -06:00
|
|
|
/* It's safe to verify table checksums during late stage */
|
|
|
|
acpi_gbl_verify_table_checksum = TRUE;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* enable workarounds, unless strict ACPI spec. compliance */
|
|
|
|
if (!acpi_strict)
|
|
|
|
acpi_gbl_enable_interpreter_slack = TRUE;
|
|
|
|
|
2016-12-14 00:04:46 -07:00
|
|
|
acpi_permanent_mmap = true;
|
2007-02-02 09:48:19 -07:00
|
|
|
|
2010-04-08 00:34:27 -06: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 09: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-16 16:20:36 -06:00
|
|
|
status = acpi_initialize_subsystem();
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2005-08-04 22:44:28 -06:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Unable to initialize the ACPI Interpreter\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
goto error0;
|
|
|
|
}
|
|
|
|
|
2016-09-22 21:26:49 -06:00
|
|
|
if (!acpi_gbl_parse_table_as_term_list &&
|
|
|
|
acpi_gbl_group_module_level_code) {
|
2016-03-23 20:43:00 -06:00
|
|
|
status = acpi_load_tables();
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Unable to load the System Description Tables\n");
|
|
|
|
goto error0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86
|
|
|
|
if (!acpi_ioapic) {
|
|
|
|
/* compatible (0) means level (3) */
|
2007-02-02 09: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-16 16:20:36 -06:00
|
|
|
/* Set PIC-mode SCI trigger type */
|
2007-02-02 09:48:22 -07:00
|
|
|
acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt,
|
2007-02-02 09:48:22 -07:00
|
|
|
(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/*
|
2007-02-02 09:48:22 -07:00
|
|
|
* now that acpi_gbl_FADT is initialized,
|
2005-04-16 16:20:36 -06:00
|
|
|
* update it with result from INT_SRC_OVR parsing
|
|
|
|
*/
|
2007-02-02 09:48:22 -07:00
|
|
|
acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#endif
|
ACPI / init: Switch over platform to the ACPI mode later
Commit 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before
timekeeping_init()" moved the ACPI subsystem initialization,
including the ACPI mode enabling, to an earlier point in the
initialization sequence, to allow the timekeeping subsystem
use ACPI early. Unfortunately, that resulted in boot regressions
on some systems and the early ACPI initialization was moved toward
its original position in the kernel initialization code by commit
c4e1acbb35e4 "ACPI / init: Invoke early ACPI initialization later".
However, that turns out to be insufficient, as boot is still broken
on the Tyan S8812 mainboard.
To fix that issue, split the ACPI early initialization code into
two pieces so the majority of it still located in acpi_early_init()
and the part switching over the platform into the ACPI mode goes into
a new function, acpi_subsystem_init(), executed at the original early
ACPI initialization spot.
That fixes the Tyan S8812 boot problem, but still allows ACPI
tables to be loaded earlier which is useful to the EFI code in
efi_enter_virtual_mode().
Link: https://bugzilla.kernel.org/show_bug.cgi?id=97141
Fixes: 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before timekeeping_init()"
Reported-and-tested-by: Marius Tolzmann <tolzmann@molgen.mpg.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Toshi Kani <toshi.kani@hp.com>
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Reviewed-by: Lee, Chun-Yi <jlee@suse.com>
2015-06-09 17:33:36 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
error0:
|
|
|
|
disable_acpi();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_subsystem_init - Finalize the early initialization of ACPI.
|
|
|
|
*
|
2016-07-03 21:13:59 -06:00
|
|
|
* Switch over the platform to the ACPI mode (if possible).
|
ACPI / init: Switch over platform to the ACPI mode later
Commit 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before
timekeeping_init()" moved the ACPI subsystem initialization,
including the ACPI mode enabling, to an earlier point in the
initialization sequence, to allow the timekeeping subsystem
use ACPI early. Unfortunately, that resulted in boot regressions
on some systems and the early ACPI initialization was moved toward
its original position in the kernel initialization code by commit
c4e1acbb35e4 "ACPI / init: Invoke early ACPI initialization later".
However, that turns out to be insufficient, as boot is still broken
on the Tyan S8812 mainboard.
To fix that issue, split the ACPI early initialization code into
two pieces so the majority of it still located in acpi_early_init()
and the part switching over the platform into the ACPI mode goes into
a new function, acpi_subsystem_init(), executed at the original early
ACPI initialization spot.
That fixes the Tyan S8812 boot problem, but still allows ACPI
tables to be loaded earlier which is useful to the EFI code in
efi_enter_virtual_mode().
Link: https://bugzilla.kernel.org/show_bug.cgi?id=97141
Fixes: 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before timekeeping_init()"
Reported-and-tested-by: Marius Tolzmann <tolzmann@molgen.mpg.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Toshi Kani <toshi.kani@hp.com>
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Reviewed-by: Lee, Chun-Yi <jlee@suse.com>
2015-06-09 17:33:36 -06:00
|
|
|
*
|
|
|
|
* Doing this too early is generally unsafe, but at the same time it needs to be
|
|
|
|
* done before all things that really depend on ACPI. The right spot appears to
|
|
|
|
* be before finalizing the EFI initialization.
|
|
|
|
*/
|
|
|
|
void __init acpi_subsystem_init(void)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
if (acpi_disabled)
|
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-11-06 06:20:42 -07:00
|
|
|
status = acpi_enable_subsystem(~ACPI_NO_ACPI_ENABLE);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
|
ACPI / init: Switch over platform to the ACPI mode later
Commit 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before
timekeeping_init()" moved the ACPI subsystem initialization,
including the ACPI mode enabling, to an earlier point in the
initialization sequence, to allow the timekeeping subsystem
use ACPI early. Unfortunately, that resulted in boot regressions
on some systems and the early ACPI initialization was moved toward
its original position in the kernel initialization code by commit
c4e1acbb35e4 "ACPI / init: Invoke early ACPI initialization later".
However, that turns out to be insufficient, as boot is still broken
on the Tyan S8812 mainboard.
To fix that issue, split the ACPI early initialization code into
two pieces so the majority of it still located in acpi_early_init()
and the part switching over the platform into the ACPI mode goes into
a new function, acpi_subsystem_init(), executed at the original early
ACPI initialization spot.
That fixes the Tyan S8812 boot problem, but still allows ACPI
tables to be loaded earlier which is useful to the EFI code in
efi_enter_virtual_mode().
Link: https://bugzilla.kernel.org/show_bug.cgi?id=97141
Fixes: 73f7d1ca3263 "ACPI / init: Run acpi_early_init() before timekeeping_init()"
Reported-and-tested-by: Marius Tolzmann <tolzmann@molgen.mpg.de>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Toshi Kani <toshi.kani@hp.com>
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Reviewed-by: Lee, Chun-Yi <jlee@suse.com>
2015-06-09 17:33:36 -06:00
|
|
|
disable_acpi();
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* If the system is using ACPI then we can be reasonably
|
|
|
|
* confident that any regulators are managed by the firmware
|
|
|
|
* so tell the regulator core it has everything it needs to
|
|
|
|
* know.
|
|
|
|
*/
|
|
|
|
regulator_has_full_constraints();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-08 10:13:09 -06:00
|
|
|
static acpi_status acpi_bus_table_handler(u32 event, void *table, void *context)
|
|
|
|
{
|
|
|
|
acpi_scan_table_handler(event, table, context);
|
|
|
|
|
|
|
|
return acpi_sysfs_table_handler(event, table, context);
|
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int __init acpi_bus_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-06-03 12:20:24 -06:00
|
|
|
int result;
|
|
|
|
acpi_status status;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-04 12:55:27 -07:00
|
|
|
acpi_os_initialize1();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ACPI 2.0 requires the EC driver to be loaded and work before
|
2016-03-23 20:43:00 -06:00
|
|
|
* the EC device is found in the namespace (i.e. before
|
|
|
|
* acpi_load_tables() is called).
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2007-02-09 23:32:16 -07:00
|
|
|
* This is accomplished by looking for the ECDT table, and getting
|
2005-04-16 16:20:36 -06:00
|
|
|
* the EC parameters out of that.
|
|
|
|
*/
|
|
|
|
status = acpi_ec_ecdt_probe();
|
|
|
|
/* Ignore result. Not having an ECDT is not fatal. */
|
|
|
|
|
2016-09-22 21:26:49 -06:00
|
|
|
if (acpi_gbl_parse_table_as_term_list ||
|
|
|
|
!acpi_gbl_group_module_level_code) {
|
2016-03-23 20:43:00 -06:00
|
|
|
status = acpi_load_tables();
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Unable to load the System Description Tables\n");
|
|
|
|
goto error1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
status = acpi_enable_subsystem(ACPI_NO_ACPI_ENABLE);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Unable to start the ACPI Interpreter\n");
|
|
|
|
goto error1;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
|
|
|
|
goto error1;
|
|
|
|
}
|
|
|
|
|
2016-03-23 22:07:39 -06:00
|
|
|
/* Set capability bits for _OSC under processor scope */
|
|
|
|
acpi_early_processor_osc();
|
|
|
|
|
2012-07-16 02:30:21 -06:00
|
|
|
/*
|
|
|
|
* _OSC method may exist in module level code,
|
|
|
|
* so it must be run after ACPI_FULL_INITIALIZATION
|
|
|
|
*/
|
|
|
|
acpi_bus_osc_support();
|
|
|
|
|
2010-10-25 20:06:54 -06:00
|
|
|
/*
|
|
|
|
* _PDC control method may load dynamic SSDT tables,
|
|
|
|
* and we need to install the table handler before that.
|
|
|
|
*/
|
2016-07-08 10:13:09 -06:00
|
|
|
status = acpi_install_table_handler(acpi_bus_table_handler, NULL);
|
|
|
|
|
2010-10-25 20:06:54 -06:00
|
|
|
acpi_sysfs_init();
|
|
|
|
|
2009-12-20 12:19:09 -07:00
|
|
|
acpi_early_processor_set_pdc();
|
|
|
|
|
2008-10-05 20:31:36 -06:00
|
|
|
/*
|
|
|
|
* Maybe EC region is required at bus_scan/acpi_get_devices. So it
|
|
|
|
* is necessary to enable it as early as possible.
|
|
|
|
*/
|
2016-06-02 20:26:12 -06:00
|
|
|
acpi_ec_dsdt_probe();
|
2008-10-05 20:31:36 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
printk(KERN_INFO PREFIX "Interpreter enabled\n");
|
|
|
|
|
2007-02-09 23:32:16 -07:00
|
|
|
/* Initialize sleep structures */
|
|
|
|
acpi_sleep_init();
|
|
|
|
|
2005-04-16 16:20:36 -06: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-04 22:44:28 -06:00
|
|
|
status =
|
|
|
|
acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
|
|
|
|
&acpi_bus_notify, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2005-08-04 22:44:28 -06:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Unable to register for device notifications\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
goto error1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create the top ACPI proc directory
|
|
|
|
*/
|
|
|
|
acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
|
|
|
|
|
2015-07-17 14:54:09 -06:00
|
|
|
result = bus_register(&acpi_bus_type);
|
|
|
|
if (!result)
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Mimic structured exception handling */
|
2005-08-04 22:44:28 -06:00
|
|
|
error1:
|
2005-04-16 16:20:36 -06:00
|
|
|
acpi_terminate();
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-11-02 17:19:59 -06:00
|
|
|
struct kobject *acpi_kobj;
|
2012-01-31 11:19:19 -07:00
|
|
|
EXPORT_SYMBOL_GPL(acpi_kobj);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int __init acpi_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-02-15 13:22:24 -07:00
|
|
|
int result;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (acpi_disabled) {
|
|
|
|
printk(KERN_INFO PREFIX "Interpreter disabled.\n");
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-11-05 14:16:15 -07:00
|
|
|
acpi_kobj = kobject_create_and_add("acpi", firmware_kobj);
|
2007-11-02 17:19:59 -06:00
|
|
|
if (!acpi_kobj) {
|
2008-03-05 19:24:51 -07:00
|
|
|
printk(KERN_WARNING "%s: kset create error\n", __func__);
|
2007-11-02 17:19:59 -06:00
|
|
|
acpi_kobj = NULL;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-24 16:50:09 -06:00
|
|
|
init_acpi_device_notify();
|
2005-04-16 16:20:36 -06:00
|
|
|
result = acpi_bus_init();
|
2011-02-15 13:22:24 -07:00
|
|
|
if (result) {
|
2005-04-16 16:20:36 -06:00
|
|
|
disable_acpi();
|
2009-03-24 16:49:38 -06:00
|
|
|
return result;
|
2011-02-15 13:22:24 -07:00
|
|
|
}
|
2009-03-24 16:49:38 -06:00
|
|
|
|
2011-02-15 13:22:24 -07:00
|
|
|
pci_mmcfg_late_init();
|
2016-09-12 12:54:20 -06:00
|
|
|
acpi_iort_init();
|
2009-03-24 16:49:43 -06:00
|
|
|
acpi_scan_init();
|
2009-03-24 16:49:48 -06:00
|
|
|
acpi_ec_init();
|
2010-07-14 20:46:15 -06:00
|
|
|
acpi_debugfs_init();
|
2009-03-24 16:50:14 -06:00
|
|
|
acpi_sleep_proc_init();
|
2009-03-24 16:50:19 -06:00
|
|
|
acpi_wakeup_device_init();
|
2015-12-02 19:43:14 -07:00
|
|
|
acpi_debugger_init();
|
2016-06-23 12:24:26 -06:00
|
|
|
acpi_setup_sb_notify_handler();
|
2011-02-15 13:22:24 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
subsys_initcall(acpi_init);
|