2018-03-14 16:13:07 -07:00
|
|
|
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
|
2012-07-15 19:15:36 -07:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* Module Name: tbxfload - Table load/unload external interfaces
|
|
|
|
*
|
2023-04-05 06:38:21 -07:00
|
|
|
* Copyright (C) 2000 - 2023, Intel Corp.
|
2012-07-15 19:15:36 -07:00
|
|
|
*
|
2018-03-14 16:13:07 -07:00
|
|
|
*****************************************************************************/
|
2012-07-15 19:15:36 -07:00
|
|
|
|
2013-10-28 18:29:51 -07:00
|
|
|
#define EXPORT_ACPI_INTERFACES
|
|
|
|
|
2012-07-15 19:15:36 -07:00
|
|
|
#include <acpi/acpi.h>
|
|
|
|
#include "accommon.h"
|
|
|
|
#include "acnamesp.h"
|
|
|
|
#include "actables.h"
|
2016-02-18 23:16:56 -07:00
|
|
|
#include "acevents.h"
|
2012-07-15 19:15:36 -07:00
|
|
|
|
|
|
|
#define _COMPONENT ACPI_TABLES
|
|
|
|
ACPI_MODULE_NAME("tbxfload")
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_load_tables
|
|
|
|
*
|
|
|
|
* PARAMETERS: None
|
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Load the ACPI tables from the RSDT/XSDT
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
2016-08-04 01:43:19 -07:00
|
|
|
acpi_status ACPI_INIT_FUNCTION acpi_load_tables(void)
|
2012-07-15 19:15:36 -07:00
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_load_tables);
|
|
|
|
|
2016-02-18 23:16:56 -07:00
|
|
|
/*
|
|
|
|
* Install the default operation region handlers. These are the
|
|
|
|
* handlers that are defined by the ACPI specification to be
|
|
|
|
* "always accessible" -- namely, system_memory, system_IO, and
|
|
|
|
* PCI_Config. This also means that no _REG methods need to be
|
|
|
|
* run for these address spaces. We need to have these handlers
|
|
|
|
* installed before any AML code can be executed, especially any
|
|
|
|
* module-level code (11/2015).
|
|
|
|
* Note that we allow OSPMs to install their own region handlers
|
|
|
|
* between acpi_initialize_subsystem() and acpi_load_tables() to use
|
|
|
|
* their customized default region handlers.
|
|
|
|
*/
|
ACPICA / Interpreter: Fix a regression triggered because of wrong Linux ECDT support
It is reported that the following commit triggers regressions:
Linux commit: efaed9be998b5ae0afb7458e057e5f4402b43fa0
ACPICA commit: 31178590dde82368fdb0f6b0e466b6c0add96c57
Subject: ACPICA: Events: Enhance acpi_ev_execute_reg_method() to
ensure no _REG evaluations can happen during OS early boot
stages
This is because that the ECDT support is not corrected in Linux, and Linux
requires to execute _REG for ECDT (though this sounds so wrong), we need to
ensure acpi_gbl_namespace_initialized is set before ECDT probing in order
for _REG to be executed. Since we have to move
"acpi_gbl_namespace_initialized = TRUE" to the initialization step
happening before ECDT probing, acpi_load_tables() is the best candidate for
now. Thus this patch fixes the regression by doing so.
But if the ECDT support is fixed, Linux will not execute _REG for ECDT, and
ECDT probing will happen before acpi_load_tables(). At that time, we still
want to ensure acpi_gbl_namespace_initialized is set after executing
acpi_ns_initialize_objects() (under the condition of
acpi_gbl_group_module_level_code = FALSE), this patch also moves
acpi_ns_initialize_objects() to acpi_load_tables() accordingly.
Since acpi_ns_initialize_objects() doesn't seem to be skippable, this
patch also removes ACPI_NO_OBJECT_INIT for the one invoked in
acpi_load_tables(). And since the default region handlers should always be
installed before loading the tables, this patch also removes useless
acpi_gbl_group_module_level_code check accordingly. Reported by Chris
Bainbridge, Fixed by Lv Zheng.
Fixes: efaed9be998b (ACPICA: Events: Enhance acpi_ev_execute_reg_method() to ensure no _REG evaluations can happen during OS early boot stages)
Reported-and-tested-by: Chris Bainbridge <chris.bainbridge@gmail.com>
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2016-03-09 19:54:29 -07:00
|
|
|
status = acpi_ev_install_region_handlers();
|
2016-03-23 18:41:32 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
ACPICA / Interpreter: Fix a regression triggered because of wrong Linux ECDT support
It is reported that the following commit triggers regressions:
Linux commit: efaed9be998b5ae0afb7458e057e5f4402b43fa0
ACPICA commit: 31178590dde82368fdb0f6b0e466b6c0add96c57
Subject: ACPICA: Events: Enhance acpi_ev_execute_reg_method() to
ensure no _REG evaluations can happen during OS early boot
stages
This is because that the ECDT support is not corrected in Linux, and Linux
requires to execute _REG for ECDT (though this sounds so wrong), we need to
ensure acpi_gbl_namespace_initialized is set before ECDT probing in order
for _REG to be executed. Since we have to move
"acpi_gbl_namespace_initialized = TRUE" to the initialization step
happening before ECDT probing, acpi_load_tables() is the best candidate for
now. Thus this patch fixes the regression by doing so.
But if the ECDT support is fixed, Linux will not execute _REG for ECDT, and
ECDT probing will happen before acpi_load_tables(). At that time, we still
want to ensure acpi_gbl_namespace_initialized is set after executing
acpi_ns_initialize_objects() (under the condition of
acpi_gbl_group_module_level_code = FALSE), this patch also moves
acpi_ns_initialize_objects() to acpi_load_tables() accordingly.
Since acpi_ns_initialize_objects() doesn't seem to be skippable, this
patch also removes ACPI_NO_OBJECT_INIT for the one invoked in
acpi_load_tables(). And since the default region handlers should always be
installed before loading the tables, this patch also removes useless
acpi_gbl_group_module_level_code check accordingly. Reported by Chris
Bainbridge, Fixed by Lv Zheng.
Fixes: efaed9be998b (ACPICA: Events: Enhance acpi_ev_execute_reg_method() to ensure no _REG evaluations can happen during OS early boot stages)
Reported-and-tested-by: Chris Bainbridge <chris.bainbridge@gmail.com>
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2016-03-09 19:54:29 -07:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status,
|
|
|
|
"During Region initialization"));
|
|
|
|
return_ACPI_STATUS(status);
|
2016-02-18 23:16:56 -07:00
|
|
|
}
|
|
|
|
|
2012-07-15 19:15:36 -07:00
|
|
|
/* Load the namespace from the tables */
|
|
|
|
|
|
|
|
status = acpi_tb_load_namespace();
|
2015-08-24 19:29:33 -07:00
|
|
|
|
|
|
|
/* Don't let single failures abort the load */
|
|
|
|
|
|
|
|
if (status == AE_CTRL_TERMINATE) {
|
|
|
|
status = AE_OK;
|
|
|
|
}
|
|
|
|
|
2012-07-15 19:15:36 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
ACPI_EXCEPTION((AE_INFO, status,
|
|
|
|
"While loading namespace from ACPI tables"));
|
|
|
|
}
|
|
|
|
|
ACPICA: Remove legacy module-level code support
ACPICA commit 47f5607c204719d9239a12b889df725225098c8f
Module-level code refers to executable ASL code that runs during
table load. This is typically used in ASL to declare named objects
based on a condition evaluated during table load like so:
definition_block(...)
{
opreation_region (OPR1, system_memory, ...)
Field (OPR1)
{
FLD1, 8 /* Assume that FLD1's value is 0x1 */
}
/* The if statement below is referred to as module-level code */
If (FLD1)
{
/* Declare DEV1 conditionally */
Device (DEV1) {...}
}
Device (DEV2)
{
...
}
}
In legacy module-level code, the execution of the If statement
was deferred after other modules were loaded. The order of
code execution for the table above is the following:
1.) Load OPR1 to the ACPI Namespace
2.) Load FLD1 to the ACPI Namespace (not intended for drivers)
3.) Load DEV2 to the ACPI Namespace
4.) Execute If (FLD1) and load DEV1 if the condition is true
This legacy approach can be problematic for tables that look like the
following:
definition_block(...)
{
opreation_region (OPR1, system_memory, ...)
Field (OPR1)
{
FLD1, 8 /* Assume that FLD1's value is 0x1 */
}
/* The if statement below is referred to as module-level code */
If (FLD1)
{
/* Declare DEV1 conditionally */
Device (DEV1) {...}
}
Scope (DEV1)
{
/* Add objects DEV1's scope */
Name (OBJ1, 0x1234)
}
}
When loading this in the legacy approach, Scope DEV1 gets evaluated
before the If statement. The following is the order of execution:
1.) Load OPR1 to the ACPI Namespace
2.) Load FLD1 to the ACPI Namespace (not intended for drivers)
3.) Add OBJ1 under DEV1's scope -- ERROR. DEV1 does not exist
4.) Execute If (FLD1) and load DEV1 if the condition is true
The legacy approach can never succeed for tables like this due to the
deferral of the module-level code. Due to this limitation, a new
module-level code was developed. This new approach exeutes if
statements in the order that they appear in the definition block.
With this approach, the order of execution for the above defintion
block is as follows:
1.) Load OPR1 to the ACPI Namespace
2.) Load FLD1 to the ACPI Namespace (not intended for drivers)
3.) Execute If (FLD1) and load DEV1 because the condition is true
4.) Add OBJ1 under DEV1's scope.
Since DEV1 is loaded in the namespace in step 3, step 4 executes
successfully.
This change removes support for the legacy module-level code
execution. From this point onward, the new module-level code
execution will be the official approach.
Link: https://github.com/acpica/acpica/commit/47f5607c
Signed-off-by: Erik Schmauss <erik.schmauss@intel.com>
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2019-02-15 14:36:06 -07:00
|
|
|
/*
|
|
|
|
* Initialize the objects in the namespace that remain uninitialized.
|
|
|
|
* This runs the executable AML that may be part of the declaration of
|
|
|
|
* these name objects:
|
|
|
|
* operation_regions, buffer_fields, Buffers, and Packages.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
status = acpi_ns_initialize_objects();
|
|
|
|
if (ACPI_SUCCESS(status)) {
|
|
|
|
acpi_gbl_namespace_initialized = TRUE;
|
ACPICA / Interpreter: Fix a regression triggered because of wrong Linux ECDT support
It is reported that the following commit triggers regressions:
Linux commit: efaed9be998b5ae0afb7458e057e5f4402b43fa0
ACPICA commit: 31178590dde82368fdb0f6b0e466b6c0add96c57
Subject: ACPICA: Events: Enhance acpi_ev_execute_reg_method() to
ensure no _REG evaluations can happen during OS early boot
stages
This is because that the ECDT support is not corrected in Linux, and Linux
requires to execute _REG for ECDT (though this sounds so wrong), we need to
ensure acpi_gbl_namespace_initialized is set before ECDT probing in order
for _REG to be executed. Since we have to move
"acpi_gbl_namespace_initialized = TRUE" to the initialization step
happening before ECDT probing, acpi_load_tables() is the best candidate for
now. Thus this patch fixes the regression by doing so.
But if the ECDT support is fixed, Linux will not execute _REG for ECDT, and
ECDT probing will happen before acpi_load_tables(). At that time, we still
want to ensure acpi_gbl_namespace_initialized is set after executing
acpi_ns_initialize_objects() (under the condition of
acpi_gbl_group_module_level_code = FALSE), this patch also moves
acpi_ns_initialize_objects() to acpi_load_tables() accordingly.
Since acpi_ns_initialize_objects() doesn't seem to be skippable, this
patch also removes ACPI_NO_OBJECT_INIT for the one invoked in
acpi_load_tables(). And since the default region handlers should always be
installed before loading the tables, this patch also removes useless
acpi_gbl_group_module_level_code check accordingly. Reported by Chris
Bainbridge, Fixed by Lv Zheng.
Fixes: efaed9be998b (ACPICA: Events: Enhance acpi_ev_execute_reg_method() to ensure no _REG evaluations can happen during OS early boot stages)
Reported-and-tested-by: Chris Bainbridge <chris.bainbridge@gmail.com>
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2016-03-09 19:54:29 -07:00
|
|
|
}
|
|
|
|
|
2012-07-15 19:15:36 -07:00
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
}
|
|
|
|
|
2013-10-28 18:30:10 -07:00
|
|
|
ACPI_EXPORT_SYMBOL_INIT(acpi_load_tables)
|
2012-07-15 19:15:36 -07:00
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_tb_load_namespace
|
|
|
|
*
|
|
|
|
* PARAMETERS: None
|
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Load the namespace from the DSDT and all SSDTs/PSDTs found in
|
|
|
|
* the RSDT/XSDT.
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
2015-08-24 19:29:33 -07:00
|
|
|
acpi_status acpi_tb_load_namespace(void)
|
2012-07-15 19:15:36 -07:00
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
u32 i;
|
|
|
|
struct acpi_table_header *new_dsdt;
|
2015-08-24 19:29:39 -07:00
|
|
|
struct acpi_table_desc *table;
|
2015-08-24 19:28:26 -07:00
|
|
|
u32 tables_loaded = 0;
|
|
|
|
u32 tables_failed = 0;
|
2012-07-15 19:15:36 -07:00
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(tb_load_namespace);
|
|
|
|
|
|
|
|
(void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Load the namespace. The DSDT is required, but any SSDT and
|
|
|
|
* PSDT tables are optional. Verify the DSDT.
|
|
|
|
*/
|
2015-08-24 19:29:39 -07:00
|
|
|
table = &acpi_gbl_root_table_list.tables[acpi_gbl_dsdt_index];
|
|
|
|
|
2012-07-15 19:15:36 -07:00
|
|
|
if (!acpi_gbl_root_table_list.current_table_count ||
|
2019-04-08 13:42:24 -07:00
|
|
|
!ACPI_COMPARE_NAMESEG(table->signature.ascii, ACPI_SIG_DSDT) ||
|
2015-08-24 19:29:39 -07:00
|
|
|
ACPI_FAILURE(acpi_tb_validate_table(table))) {
|
2012-07-15 19:15:36 -07:00
|
|
|
status = AE_NO_ACPI_TABLES;
|
|
|
|
goto unlock_and_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Save the DSDT pointer for simple access. This is the mapped memory
|
|
|
|
* address. We must take care here because the address of the .Tables
|
|
|
|
* array can change dynamically as tables are loaded at run-time. Note:
|
ACPICA: Tables: Clean up split INSTALLED/VALIDATED table state logics.
This patch is mainly a naming cleanup to clarify hidden logics, no
functional changes.
acpi_initialize_tables() is used by Linux to install table addresses for
early boot steps. During this stage, table addresses are mapped by
early_ioremap() mechanism which is different from the runtime IO mappings.
Thus it is not safe for ACPICA to keep mapped pointers in struct acpi_table_desc
structure during this stage.
In order to support this in ACPICA, table states are divided into
1. "INSTALLED" (where struct acpi_table_desc.Pointer is always NULL) and
2. "VALIDATED" (where struct acpi_table_desc.Pointer is always not NULL).
During acpi_initialize_tables(), table state are ensured to be "INSTALLED"
but not "VALIDATED". This logic is ensured by the original code in very
ambigious way. For example, currently acpi_tb_delete_table() is invoked in
some place to perform an uninstallation while it is invoked in other place
to perform an invalidation. They happen to work just because no one enters
the penalty where the 2 behaviours are not equivalent.
The naming cleanups are made in this patch:
A. For installation and validation:
There is code setting struct acpi_table_desc.Pointer first and delete it
immediately to keep the descriptor's state as "INSTALLED" during the
installation. This patch implements this in more direct way. After
applying it, struct acpi_table_desc.Pointer will never be set in
acpi_tb_install_table() and acpi_tb_override_table() as they are the only
functions invoked during acpi_initialize_tables(). This is achieved by:
1. Rename acpi_tb_verify_table() to acpi_tb_validate_table() to clarify this
change.
2. Rename acpi_tb_table_override() to acpi_tb_override_table() to keep nameing
consistencies as other APIs (verb. Table).
3. Stops setting struct acpi_table_desc.Pointer in acpi_tb_install_table() and
acpi_tb_table_override().
4. Introduce acpi_tb_acquire_table() to acquire the table pointer that is not
maintained in the struct acpi_table_desc of the global root table list and
rewrite acpi_tb_validate_table() using this new function to reduce
redundancies.
5. Replace the table pointer using the overridden table pointer in
acpi_tb_add_table(). As acpi_tb_add_table() is not invoked during early boot
stage, tables returned from this functions should be "VALIDATED". As
acpi_tb_override_table() is modified by this patch to return a "INSTALLED"
but not "VALIDATED" descriptor, to keep acpi_tb_add_table() unchanged,
struct acpi_table_desc.Pointer is filled in acpi_tb_add_table().
B. For invalidation and uninstallation:
The original code invalidate table by invoking acpi_tb_delete_table() here
and there, but actually this function should only be used to uninstall
tables. This can work just because its invocations are equivalent to
invalidation in some cases.
This patch splits acpi_tb_delete_table() into acpi_tb_invalidate_table() and
acpi_tb_uninstall_table() and cleans up the hidden logic using the new
APIs. This is achieved by:
1. Rename acpi_tb_delete_table() to acpi_tb_uninstall_table() as it is mainly
called before resetting struct acpi_table_desc.Address. Thus the table
descriptor is in "not INSTALLED" state. This patch enforces this by
setting struct acpi_table_desc.Address to NULL in this function.
2. Introduce acpi_tb_invalidate_table() to be the reversal of
acpi_tb_validate_table() and invoke it in acpi_tb_uninstall_table().
3. Introduce acpi_tb_release_table() to release the table pointer that is not
maintained in acpi_gbl_root_table_list and rewrite acpi_tb_invalidate_table()
using this new function to reduce redundancies.
After cleaning up, the maintainability of the internal APIs are also
improved:
1. acpi_tb_acquire_table: Acquire struct acpi_table_header according to
ACPI_TABLE_ORIGIN_xxx flags.
2. acpi_tb_release_table: Release struct acpi_table_header according to
ACPI_TABLE_ORIGIN_xxx flags.
3. acpi_tb_install_table: Make struct acpi_table_desc.Address not NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
4. acpi_tb_uninstall_table: Make struct acpi_table_desc.Address NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
5. acpi_tb_validate_table: Make struct acpi_table_desc.Pointer not NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
6. acpi_tb_invalidate_table: Make struct acpi_table_desc.Pointer NULL according to
ACPI_TABLE_ORIGIN_xxx flags.
7. acpi_tb_override_table: Replace struct acpi_table_desc.Address and
struct acpi_table_desc.Flags. It only happens in
"INSTALLED" state.
The patch has been unit tested in acpi_exec by:
1. Initializing;
2. Executing exc_tbl ASLTS tests;
3. Executing "Load" command.
So that all original acpi_tb_install_table() and acpi_tb_override_table()
invocations are covered.
Known Issues:
1. Cleanup acpi_tb_add_table() to Kill Code Redundancies
Current implementation in acpi_tb_add_table() is not very clean, further
patch can rewrite acpi_tb_add_table() with ordered acpi_tb_install_table(),
acpi_tb_override_table() and acpi_tb_validate_table(). It is not done in this
patch so that it is easy for the reviewers to understand the changes in
this patch.
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-04-03 21:38:42 -07:00
|
|
|
* .Pointer field is not validated until after call to acpi_tb_validate_table.
|
2012-07-15 19:15:36 -07:00
|
|
|
*/
|
2015-08-24 19:29:39 -07:00
|
|
|
acpi_gbl_DSDT = table->pointer;
|
2012-07-15 19:15:36 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Optionally copy the entire DSDT to local memory (instead of simply
|
|
|
|
* mapping it.) There are some BIOSs that corrupt or replace the original
|
|
|
|
* DSDT, creating the need for this option. Default is FALSE, do not copy
|
|
|
|
* the DSDT.
|
|
|
|
*/
|
|
|
|
if (acpi_gbl_copy_dsdt_locally) {
|
2015-08-24 19:29:01 -07:00
|
|
|
new_dsdt = acpi_tb_copy_dsdt(acpi_gbl_dsdt_index);
|
2012-07-15 19:15:36 -07:00
|
|
|
if (new_dsdt) {
|
|
|
|
acpi_gbl_DSDT = new_dsdt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Save the original DSDT header for detection of table corruption
|
|
|
|
* and/or replacement of the DSDT from outside the OS.
|
|
|
|
*/
|
2015-06-30 23:45:11 -07:00
|
|
|
memcpy(&acpi_gbl_original_dsdt_header, acpi_gbl_DSDT,
|
|
|
|
sizeof(struct acpi_table_header));
|
2012-07-15 19:15:36 -07:00
|
|
|
|
|
|
|
/* Load and parse tables */
|
|
|
|
|
2016-09-06 23:07:24 -07:00
|
|
|
(void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
|
2015-08-24 19:29:01 -07:00
|
|
|
status = acpi_ns_load_table(acpi_gbl_dsdt_index, acpi_gbl_root_node);
|
2016-09-06 23:07:24 -07:00
|
|
|
(void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
|
2012-07-15 19:15:36 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2015-08-24 19:28:26 -07:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "[DSDT] table load failed"));
|
|
|
|
tables_failed++;
|
|
|
|
} else {
|
|
|
|
tables_loaded++;
|
2012-07-15 19:15:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Load any SSDT or PSDT tables. Note: Loop leaves tables locked */
|
|
|
|
|
|
|
|
for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) {
|
2015-08-24 19:29:39 -07:00
|
|
|
table = &acpi_gbl_root_table_list.tables[i];
|
|
|
|
|
2017-07-10 00:23:37 -07:00
|
|
|
if (!table->address ||
|
2019-04-08 13:42:24 -07:00
|
|
|
(!ACPI_COMPARE_NAMESEG
|
|
|
|
(table->signature.ascii, ACPI_SIG_SSDT)
|
|
|
|
&& !ACPI_COMPARE_NAMESEG(table->signature.ascii,
|
|
|
|
ACPI_SIG_PSDT)
|
|
|
|
&& !ACPI_COMPARE_NAMESEG(table->signature.ascii,
|
|
|
|
ACPI_SIG_OSDT))
|
2015-08-24 19:29:39 -07:00
|
|
|
|| ACPI_FAILURE(acpi_tb_validate_table(table))) {
|
2012-07-15 19:15:36 -07:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Ignore errors while loading tables, get as many as possible */
|
|
|
|
|
|
|
|
(void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
|
2015-08-24 19:28:26 -07:00
|
|
|
status = acpi_ns_load_table(i, acpi_gbl_root_node);
|
2016-09-06 23:07:24 -07:00
|
|
|
(void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
|
2015-08-24 19:28:26 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
ACPI_EXCEPTION((AE_INFO, status,
|
2015-08-24 19:29:39 -07:00
|
|
|
"(%4.4s:%8.8s) while loading table",
|
|
|
|
table->signature.ascii,
|
|
|
|
table->pointer->oem_table_id));
|
2015-12-28 22:54:36 -07:00
|
|
|
|
2015-08-24 19:28:26 -07:00
|
|
|
tables_failed++;
|
2015-08-24 19:29:39 -07:00
|
|
|
|
|
|
|
ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
|
|
|
|
"Table [%4.4s:%8.8s] (id FF) - Table namespace load failed\n\n",
|
|
|
|
table->signature.ascii,
|
|
|
|
table->pointer->oem_table_id));
|
2015-08-24 19:28:26 -07:00
|
|
|
} else {
|
|
|
|
tables_loaded++;
|
|
|
|
}
|
2012-07-15 19:15:36 -07:00
|
|
|
}
|
|
|
|
|
2015-08-24 19:28:26 -07:00
|
|
|
if (!tables_failed) {
|
2016-10-17 12:02:24 -07:00
|
|
|
ACPI_INFO(("%u ACPI AML tables successfully acquired and loaded", tables_loaded));
|
2015-08-24 19:28:26 -07:00
|
|
|
} else {
|
|
|
|
ACPI_ERROR((AE_INFO,
|
2015-08-24 19:29:39 -07:00
|
|
|
"%u table load failures, %u successful",
|
|
|
|
tables_failed, tables_loaded));
|
2015-08-24 19:29:33 -07:00
|
|
|
|
|
|
|
/* Indicate at least one failure */
|
|
|
|
|
|
|
|
status = AE_CTRL_TERMINATE;
|
2015-08-24 19:28:26 -07:00
|
|
|
}
|
2012-07-15 19:15:36 -07:00
|
|
|
|
2016-10-17 12:02:24 -07:00
|
|
|
#ifdef ACPI_APPLICATION
|
|
|
|
ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, "\n"));
|
|
|
|
#endif
|
|
|
|
|
2013-10-28 18:30:02 -07:00
|
|
|
unlock_and_exit:
|
2012-07-15 19:15:36 -07:00
|
|
|
(void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
}
|
|
|
|
|
2014-04-03 21:39:18 -07:00
|
|
|
/*******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_install_table
|
|
|
|
*
|
ACPICA: Use original pointer for virtual origin tables
ACPICA commit dfa3feffa8f760b686207d09dc880cd2f26c72af
Currently the pointer to the table is cast to acpi_physical_address and
later cast back to a pointer to be dereferenced. Whether or not this is
supported is implementation-defined.
On CHERI, and thus Arm's experimental Morello prototype architecture,
pointers are represented as capabilities, which are unforgeable bounded
pointers, providing always-on fine-grained spatial memory safety. This
means that any pointer cast to a plain integer will lose all its
associated metadata, and when cast back to a pointer it will give a
null-derived pointer (one that has the same metadata as null but an
address equal to the integer) that will trap on any dereference. As a
result, this is an implementation where acpi_physical_address cannot be
used as a hack to store real pointers.
Thus, alter the lifecycle of table descriptors. Internal physical tables
keep the current behaviour where only the address is set on install, and
the pointer is set on acquire. Virtual tables (internal and external)
now store the pointer on initialisation and use that on acquire (which
will redundantly set *table_ptr to itself, but changing that is both
unnecessary and overly complicated as acpi_tb_acquire_table is called with
both a pointer to a variable and a pointer to Table->Pointer itself).
This requires propagating the (possible) table pointer everywhere in
order to make sure pointers make it through to acpi_tb_acquire_temp_table,
which requires a change to the acpi_install_table interface. Instead of
taking an ACPI_PHYSADDR_TYPE and a boolean indicating whether it's
physical or virtual, it is now split into acpi_install_table (that takes
an external virtual table pointer) and acpi_install_physical_table (that
takes an ACPI_PHYSADDR_TYPE for an internal physical table address).
This also has the benefit of providing a cleaner API.
Link: https://github.com/acpica/acpica/commit/dfa3feff
Signed-off-by: Bob Moore <robert.moore@intel.com>
[ rjw: Adjust the code in tables.c to match interface changes ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-22 09:22:28 -07:00
|
|
|
* PARAMETERS: table - Pointer to the ACPI table to be installed.
|
2014-04-03 21:39:18 -07:00
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Dynamically install an ACPI table.
|
|
|
|
* Note: This function should only be invoked after
|
|
|
|
* acpi_initialize_tables() and before acpi_load_tables().
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
2016-08-04 01:43:19 -07:00
|
|
|
acpi_status ACPI_INIT_FUNCTION
|
ACPICA: Use original pointer for virtual origin tables
ACPICA commit dfa3feffa8f760b686207d09dc880cd2f26c72af
Currently the pointer to the table is cast to acpi_physical_address and
later cast back to a pointer to be dereferenced. Whether or not this is
supported is implementation-defined.
On CHERI, and thus Arm's experimental Morello prototype architecture,
pointers are represented as capabilities, which are unforgeable bounded
pointers, providing always-on fine-grained spatial memory safety. This
means that any pointer cast to a plain integer will lose all its
associated metadata, and when cast back to a pointer it will give a
null-derived pointer (one that has the same metadata as null but an
address equal to the integer) that will trap on any dereference. As a
result, this is an implementation where acpi_physical_address cannot be
used as a hack to store real pointers.
Thus, alter the lifecycle of table descriptors. Internal physical tables
keep the current behaviour where only the address is set on install, and
the pointer is set on acquire. Virtual tables (internal and external)
now store the pointer on initialisation and use that on acquire (which
will redundantly set *table_ptr to itself, but changing that is both
unnecessary and overly complicated as acpi_tb_acquire_table is called with
both a pointer to a variable and a pointer to Table->Pointer itself).
This requires propagating the (possible) table pointer everywhere in
order to make sure pointers make it through to acpi_tb_acquire_temp_table,
which requires a change to the acpi_install_table interface. Instead of
taking an ACPI_PHYSADDR_TYPE and a boolean indicating whether it's
physical or virtual, it is now split into acpi_install_table (that takes
an external virtual table pointer) and acpi_install_physical_table (that
takes an ACPI_PHYSADDR_TYPE for an internal physical table address).
This also has the benefit of providing a cleaner API.
Link: https://github.com/acpica/acpica/commit/dfa3feff
Signed-off-by: Bob Moore <robert.moore@intel.com>
[ rjw: Adjust the code in tables.c to match interface changes ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-22 09:22:28 -07:00
|
|
|
acpi_install_table(struct acpi_table_header *table)
|
2014-04-03 21:39:18 -07:00
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
u32 table_index;
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_install_table);
|
|
|
|
|
ACPICA: Use original pointer for virtual origin tables
ACPICA commit dfa3feffa8f760b686207d09dc880cd2f26c72af
Currently the pointer to the table is cast to acpi_physical_address and
later cast back to a pointer to be dereferenced. Whether or not this is
supported is implementation-defined.
On CHERI, and thus Arm's experimental Morello prototype architecture,
pointers are represented as capabilities, which are unforgeable bounded
pointers, providing always-on fine-grained spatial memory safety. This
means that any pointer cast to a plain integer will lose all its
associated metadata, and when cast back to a pointer it will give a
null-derived pointer (one that has the same metadata as null but an
address equal to the integer) that will trap on any dereference. As a
result, this is an implementation where acpi_physical_address cannot be
used as a hack to store real pointers.
Thus, alter the lifecycle of table descriptors. Internal physical tables
keep the current behaviour where only the address is set on install, and
the pointer is set on acquire. Virtual tables (internal and external)
now store the pointer on initialisation and use that on acquire (which
will redundantly set *table_ptr to itself, but changing that is both
unnecessary and overly complicated as acpi_tb_acquire_table is called with
both a pointer to a variable and a pointer to Table->Pointer itself).
This requires propagating the (possible) table pointer everywhere in
order to make sure pointers make it through to acpi_tb_acquire_temp_table,
which requires a change to the acpi_install_table interface. Instead of
taking an ACPI_PHYSADDR_TYPE and a boolean indicating whether it's
physical or virtual, it is now split into acpi_install_table (that takes
an external virtual table pointer) and acpi_install_physical_table (that
takes an ACPI_PHYSADDR_TYPE for an internal physical table address).
This also has the benefit of providing a cleaner API.
Link: https://github.com/acpica/acpica/commit/dfa3feff
Signed-off-by: Bob Moore <robert.moore@intel.com>
[ rjw: Adjust the code in tables.c to match interface changes ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-22 09:22:28 -07:00
|
|
|
status = acpi_tb_install_standard_table(ACPI_PTR_TO_PHYSADDR(table),
|
|
|
|
ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL,
|
|
|
|
table, FALSE, FALSE,
|
|
|
|
&table_index);
|
2014-04-03 21:39:18 -07:00
|
|
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
}
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL_INIT(acpi_install_table)
|
|
|
|
|
ACPICA: Use original pointer for virtual origin tables
ACPICA commit dfa3feffa8f760b686207d09dc880cd2f26c72af
Currently the pointer to the table is cast to acpi_physical_address and
later cast back to a pointer to be dereferenced. Whether or not this is
supported is implementation-defined.
On CHERI, and thus Arm's experimental Morello prototype architecture,
pointers are represented as capabilities, which are unforgeable bounded
pointers, providing always-on fine-grained spatial memory safety. This
means that any pointer cast to a plain integer will lose all its
associated metadata, and when cast back to a pointer it will give a
null-derived pointer (one that has the same metadata as null but an
address equal to the integer) that will trap on any dereference. As a
result, this is an implementation where acpi_physical_address cannot be
used as a hack to store real pointers.
Thus, alter the lifecycle of table descriptors. Internal physical tables
keep the current behaviour where only the address is set on install, and
the pointer is set on acquire. Virtual tables (internal and external)
now store the pointer on initialisation and use that on acquire (which
will redundantly set *table_ptr to itself, but changing that is both
unnecessary and overly complicated as acpi_tb_acquire_table is called with
both a pointer to a variable and a pointer to Table->Pointer itself).
This requires propagating the (possible) table pointer everywhere in
order to make sure pointers make it through to acpi_tb_acquire_temp_table,
which requires a change to the acpi_install_table interface. Instead of
taking an ACPI_PHYSADDR_TYPE and a boolean indicating whether it's
physical or virtual, it is now split into acpi_install_table (that takes
an external virtual table pointer) and acpi_install_physical_table (that
takes an ACPI_PHYSADDR_TYPE for an internal physical table address).
This also has the benefit of providing a cleaner API.
Link: https://github.com/acpica/acpica/commit/dfa3feff
Signed-off-by: Bob Moore <robert.moore@intel.com>
[ rjw: Adjust the code in tables.c to match interface changes ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-22 09:22:28 -07:00
|
|
|
/*******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_install_physical_table
|
|
|
|
*
|
|
|
|
* PARAMETERS: address - Address of the ACPI table to be installed.
|
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Dynamically install an ACPI table.
|
|
|
|
* Note: This function should only be invoked after
|
|
|
|
* acpi_initialize_tables() and before acpi_load_tables().
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
acpi_status ACPI_INIT_FUNCTION
|
|
|
|
acpi_install_physical_table(acpi_physical_address address)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
u32 table_index;
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_install_physical_table);
|
|
|
|
|
|
|
|
status = acpi_tb_install_standard_table(address,
|
|
|
|
ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL,
|
|
|
|
NULL, FALSE, FALSE,
|
|
|
|
&table_index);
|
|
|
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
}
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL_INIT(acpi_install_physical_table)
|
|
|
|
|
2012-07-15 19:21:34 -07:00
|
|
|
/*******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_load_table
|
|
|
|
*
|
|
|
|
* PARAMETERS: table - Pointer to a buffer containing the ACPI
|
|
|
|
* table to be loaded.
|
2019-10-25 14:36:53 -07:00
|
|
|
* table_idx - Pointer to a u32 for storing the table
|
|
|
|
* index, might be NULL
|
2012-07-15 19:21:34 -07:00
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Dynamically load an ACPI table from the caller's buffer. Must
|
|
|
|
* be a valid ACPI table with a valid ACPI table header.
|
|
|
|
* Note1: Mainly intended to support hotplug addition of SSDTs.
|
2012-10-30 19:26:23 -07:00
|
|
|
* Note2: Does not copy the incoming table. User is responsible
|
2012-07-15 19:21:34 -07:00
|
|
|
* to ensure that the table is not deleted or unmapped.
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
2019-10-25 14:36:53 -07:00
|
|
|
acpi_status acpi_load_table(struct acpi_table_header *table, u32 *table_idx)
|
2012-07-15 19:21:34 -07:00
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
u32 table_index;
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_load_table);
|
|
|
|
|
|
|
|
/* Parameter validation */
|
|
|
|
|
|
|
|
if (!table) {
|
|
|
|
return_ACPI_STATUS(AE_BAD_PARAMETER);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Install the table and load it into the namespace */
|
|
|
|
|
2016-02-18 23:16:42 -07:00
|
|
|
ACPI_INFO(("Host-directed Dynamic ACPI Table Load:"));
|
2016-11-30 00:21:19 -07:00
|
|
|
status = acpi_tb_install_and_load_table(ACPI_PTR_TO_PHYSADDR(table),
|
|
|
|
ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL,
|
ACPICA: Use original pointer for virtual origin tables
ACPICA commit dfa3feffa8f760b686207d09dc880cd2f26c72af
Currently the pointer to the table is cast to acpi_physical_address and
later cast back to a pointer to be dereferenced. Whether or not this is
supported is implementation-defined.
On CHERI, and thus Arm's experimental Morello prototype architecture,
pointers are represented as capabilities, which are unforgeable bounded
pointers, providing always-on fine-grained spatial memory safety. This
means that any pointer cast to a plain integer will lose all its
associated metadata, and when cast back to a pointer it will give a
null-derived pointer (one that has the same metadata as null but an
address equal to the integer) that will trap on any dereference. As a
result, this is an implementation where acpi_physical_address cannot be
used as a hack to store real pointers.
Thus, alter the lifecycle of table descriptors. Internal physical tables
keep the current behaviour where only the address is set on install, and
the pointer is set on acquire. Virtual tables (internal and external)
now store the pointer on initialisation and use that on acquire (which
will redundantly set *table_ptr to itself, but changing that is both
unnecessary and overly complicated as acpi_tb_acquire_table is called with
both a pointer to a variable and a pointer to Table->Pointer itself).
This requires propagating the (possible) table pointer everywhere in
order to make sure pointers make it through to acpi_tb_acquire_temp_table,
which requires a change to the acpi_install_table interface. Instead of
taking an ACPI_PHYSADDR_TYPE and a boolean indicating whether it's
physical or virtual, it is now split into acpi_install_table (that takes
an external virtual table pointer) and acpi_install_physical_table (that
takes an ACPI_PHYSADDR_TYPE for an internal physical table address).
This also has the benefit of providing a cleaner API.
Link: https://github.com/acpica/acpica/commit/dfa3feff
Signed-off-by: Bob Moore <robert.moore@intel.com>
[ rjw: Adjust the code in tables.c to match interface changes ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-22 09:22:28 -07:00
|
|
|
table, FALSE, &table_index);
|
2019-10-25 14:36:53 -07:00
|
|
|
if (table_idx) {
|
|
|
|
*table_idx = table_index;
|
|
|
|
}
|
|
|
|
|
2019-07-10 02:52:50 -07:00
|
|
|
if (ACPI_SUCCESS(status)) {
|
2019-07-03 13:15:39 -07:00
|
|
|
|
2019-07-11 09:58:21 -07:00
|
|
|
/* Complete the initialization/resolution of new objects */
|
|
|
|
|
|
|
|
acpi_ns_initialize_objects();
|
2019-06-12 01:36:06 -07:00
|
|
|
}
|
|
|
|
|
2012-07-15 19:21:34 -07:00
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
}
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_load_table)
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_unload_parent_table
|
|
|
|
*
|
|
|
|
* PARAMETERS: object - Handle to any namespace object owned by
|
|
|
|
* the table to be unloaded
|
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Via any namespace object within an SSDT or OEMx table, unloads
|
|
|
|
* the table and deletes all namespace objects associated with
|
|
|
|
* that table. Unloading of the DSDT is not allowed.
|
|
|
|
* Note: Mainly intended to support hotplug removal of SSDTs.
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
acpi_status acpi_unload_parent_table(acpi_handle object)
|
|
|
|
{
|
|
|
|
struct acpi_namespace_node *node =
|
|
|
|
ACPI_CAST_PTR(struct acpi_namespace_node, object);
|
|
|
|
acpi_status status = AE_NOT_EXIST;
|
|
|
|
acpi_owner_id owner_id;
|
|
|
|
u32 i;
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_unload_parent_table);
|
|
|
|
|
|
|
|
/* Parameter validation */
|
|
|
|
|
|
|
|
if (!object) {
|
|
|
|
return_ACPI_STATUS(AE_BAD_PARAMETER);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The node owner_id is currently the same as the parent table ID.
|
|
|
|
* However, this could change in the future.
|
|
|
|
*/
|
|
|
|
owner_id = node->owner_id;
|
|
|
|
if (!owner_id) {
|
|
|
|
|
|
|
|
/* owner_id==0 means DSDT is the owner. DSDT cannot be unloaded */
|
|
|
|
|
|
|
|
return_ACPI_STATUS(AE_TYPE);
|
|
|
|
}
|
|
|
|
|
2016-09-22 20:26:35 -07:00
|
|
|
/* Must acquire the table lock during this operation */
|
2012-07-15 19:21:34 -07:00
|
|
|
|
2016-09-22 20:26:35 -07:00
|
|
|
status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
|
2012-07-15 19:21:34 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find the table in the global table list */
|
|
|
|
|
|
|
|
for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) {
|
|
|
|
if (owner_id != acpi_gbl_root_table_list.tables[i].owner_id) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allow unload of SSDT and OEMx tables only. Do not allow unload
|
|
|
|
* of the DSDT. No other types of tables should get here, since
|
|
|
|
* only these types can contain AML and thus are the only types
|
|
|
|
* that can create namespace objects.
|
|
|
|
*/
|
2019-04-08 13:42:24 -07:00
|
|
|
if (ACPI_COMPARE_NAMESEG
|
2012-07-15 19:21:34 -07:00
|
|
|
(acpi_gbl_root_table_list.tables[i].signature.ascii,
|
|
|
|
ACPI_SIG_DSDT)) {
|
|
|
|
status = AE_TYPE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-09-22 20:26:35 -07:00
|
|
|
(void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
|
2016-11-30 00:21:26 -07:00
|
|
|
status = acpi_tb_unload_table(i);
|
2016-09-22 20:26:35 -07:00
|
|
|
(void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
|
2012-07-15 19:21:34 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-09-22 20:26:35 -07:00
|
|
|
(void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
|
2012-07-15 19:21:34 -07:00
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
}
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_unload_parent_table)
|
2019-10-25 14:36:52 -07:00
|
|
|
/*******************************************************************************
|
|
|
|
*
|
|
|
|
* FUNCTION: acpi_unload_table
|
|
|
|
*
|
|
|
|
* PARAMETERS: table_index - Index as returned by acpi_load_table
|
|
|
|
*
|
|
|
|
* RETURN: Status
|
|
|
|
*
|
|
|
|
* DESCRIPTION: Via the table_index representing an SSDT or OEMx table, unloads
|
|
|
|
* the table and deletes all namespace objects associated with
|
|
|
|
* that table. Unloading of the DSDT is not allowed.
|
|
|
|
* Note: Mainly intended to support hotplug removal of SSDTs.
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
acpi_status acpi_unload_table(u32 table_index)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_unload_table);
|
|
|
|
|
|
|
|
if (table_index == 1) {
|
|
|
|
|
|
|
|
/* table_index==1 means DSDT is the owner. DSDT cannot be unloaded */
|
|
|
|
|
|
|
|
return_ACPI_STATUS(AE_TYPE);
|
|
|
|
}
|
|
|
|
|
|
|
|
status = acpi_tb_unload_table(table_index);
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
}
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_unload_table)
|