Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 487 insertions, 0 deletions

diff --git a/drivers/acpi/executer/exconfig.c b/drivers/acpi/executer/exconfig.c
new file mode 100644
index 000000000000..ac3c061967f2
--- /dev/null
+++ b/drivers/acpi/executer/exconfig.c
@@ -0,0 +1,487 @@
+/******************************************************************************
+ *
+ * Module Name: exconfig - Namespace reconfiguration (Load/Unload opcodes)
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2005, R. Byron Moore
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+
+#include <acpi/acpi.h>
+#include <acpi/acinterp.h>
+#include <acpi/amlcode.h>
+#include <acpi/acnamesp.h>
+#include <acpi/acevents.h>
+#include <acpi/actables.h>
+#include <acpi/acdispat.h>
+
+
+#define _COMPONENT          ACPI_EXECUTER
+         ACPI_MODULE_NAME    ("exconfig")
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ex_add_table
+ *
+ * PARAMETERS:  Table               - Pointer to raw table
+ *              parent_node         - Where to load the table (scope)
+ *              ddb_handle          - Where to return the table handle.
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Common function to Install and Load an ACPI table with a
+ *              returned table handle.
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_ex_add_table (
+        struct acpi_table_header        *table,
+        struct acpi_namespace_node      *parent_node,
+        union acpi_operand_object       **ddb_handle)
+{
+        acpi_status                     status;
+        struct acpi_table_desc          table_info;
+        union acpi_operand_object       *obj_desc;
+
+
+        ACPI_FUNCTION_TRACE ("ex_add_table");
+
+
+        /* Create an object to be the table handle */
+
+        obj_desc = acpi_ut_create_internal_object (ACPI_TYPE_LOCAL_REFERENCE);
+        if (!obj_desc) {
+                return_ACPI_STATUS (AE_NO_MEMORY);
+        }
+
+        /* Install the new table into the local data structures */
+
+        ACPI_MEMSET (&table_info, 0, sizeof (struct acpi_table_desc));
+
+        table_info.type        = ACPI_TABLE_SSDT;
+        table_info.pointer     = table;
+        table_info.length      = (acpi_size) table->length;
+        table_info.allocation  = ACPI_MEM_ALLOCATED;
+
+        status = acpi_tb_install_table (&table_info);
+        if (ACPI_FAILURE (status)) {
+                goto cleanup;
+        }
+
+        /* Add the table to the namespace */
+
+        status = acpi_ns_load_table (table_info.installed_desc, parent_node);
+        if (ACPI_FAILURE (status)) {
+                /* Uninstall table on error */
+
+                (void) acpi_tb_uninstall_table (table_info.installed_desc);
+                goto cleanup;
+        }
+
+        /* Init the table handle */
+
+        obj_desc->reference.opcode = AML_LOAD_OP;
+        obj_desc->reference.object = table_info.installed_desc;
+        *ddb_handle = obj_desc;
+        return_ACPI_STATUS (AE_OK);
+
+
+cleanup:
+        acpi_ut_remove_reference (obj_desc);
+        return_ACPI_STATUS (status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ex_load_table_op
+ *
+ * PARAMETERS:  walk_state          - Current state with operands
+ *              return_desc         - Where to store the return object
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Load an ACPI table
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_ex_load_table_op (
+        struct acpi_walk_state          *walk_state,
+        union acpi_operand_object       **return_desc)
+{
+        acpi_status                     status;
+        union acpi_operand_object       **operand = &walk_state->operands[0];
+        struct acpi_table_header        *table;
+        struct acpi_namespace_node      *parent_node;
+        struct acpi_namespace_node      *start_node;
+        struct acpi_namespace_node      *parameter_node = NULL;
+        union acpi_operand_object       *ddb_handle;
+
+
+        ACPI_FUNCTION_TRACE ("ex_load_table_op");
+
+
+#if 0
+        /*
+         * Make sure that the signature does not match one of the tables that
+         * is already loaded.
+         */
+        status = acpi_tb_match_signature (operand[0]->string.pointer, NULL);
+        if (status == AE_OK) {
+                /* Signature matched -- don't allow override */
+
+                return_ACPI_STATUS (AE_ALREADY_EXISTS);
+        }
+#endif
+
+        /* Find the ACPI table */
+
+        status = acpi_tb_find_table (operand[0]->string.pointer,
+                           operand[1]->string.pointer,
+                           operand[2]->string.pointer, &table);
+        if (ACPI_FAILURE (status)) {
+                if (status != AE_NOT_FOUND) {
+                        return_ACPI_STATUS (status);
+                }
+
+                /* Table not found, return an Integer=0 and AE_OK */
+
+                ddb_handle = acpi_ut_create_internal_object (ACPI_TYPE_INTEGER);
+                if (!ddb_handle) {
+                        return_ACPI_STATUS (AE_NO_MEMORY);
+                }
+
+                ddb_handle->integer.value = 0;
+                *return_desc = ddb_handle;
+
+                return_ACPI_STATUS (AE_OK);
+        }
+
+        /* Default nodes */
+
+        start_node = walk_state->scope_info->scope.node;
+        parent_node = acpi_gbl_root_node;
+
+        /* root_path (optional parameter) */
+
+        if (operand[3]->string.length > 0) {
+                /*
+                 * Find the node referenced by the root_path_string. This is the
+                 * location within the namespace where the table will be loaded.
+                 */
+                status = acpi_ns_get_node_by_path (operand[3]->string.pointer, start_node,
+                                   ACPI_NS_SEARCH_PARENT, &parent_node);
+                if (ACPI_FAILURE (status)) {
+                        return_ACPI_STATUS (status);
+                }
+        }
+
+        /* parameter_path (optional parameter) */
+
+        if (operand[4]->string.length > 0) {
+                if ((operand[4]->string.pointer[0] != '\\') &&
+                        (operand[4]->string.pointer[0] != '^')) {
+                        /*
+                         * Path is not absolute, so it will be relative to the node
+                         * referenced by the root_path_string (or the NS root if omitted)
+                         */
+                        start_node = parent_node;
+                }
+
+                /*
+                 * Find the node referenced by the parameter_path_string
+                 */
+                status = acpi_ns_get_node_by_path (operand[4]->string.pointer, start_node,
+                                   ACPI_NS_SEARCH_PARENT, &parameter_node);
+                if (ACPI_FAILURE (status)) {
+                        return_ACPI_STATUS (status);
+                }
+        }
+
+        /* Load the table into the namespace */
+
+        status = acpi_ex_add_table (table, parent_node, &ddb_handle);
+        if (ACPI_FAILURE (status)) {
+                return_ACPI_STATUS (status);
+        }
+
+        /* Parameter Data (optional) */
+
+        if (parameter_node) {
+                /* Store the parameter data into the optional parameter object */
+
+                status = acpi_ex_store (operand[5], ACPI_CAST_PTR (union acpi_operand_object, parameter_node),
+                                 walk_state);
+                if (ACPI_FAILURE (status)) {
+                        (void) acpi_ex_unload_table (ddb_handle);
+                        return_ACPI_STATUS (status);
+                }
+        }
+
+        *return_desc = ddb_handle;
+        return_ACPI_STATUS  (status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ex_load_op
+ *
+ * PARAMETERS:  obj_desc        - Region or Field where the table will be
+ *                                obtained
+ *              Target          - Where a handle to the table will be stored
+ *              walk_state      - Current state
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Load an ACPI table from a field or operation region
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_ex_load_op (
+        union acpi_operand_object       *obj_desc,
+        union acpi_operand_object       *target,
+        struct acpi_walk_state          *walk_state)
+{
+        acpi_status                     status;
+        union acpi_operand_object       *ddb_handle;
+        union acpi_operand_object       *buffer_desc = NULL;
+        struct acpi_table_header        *table_ptr = NULL;
+        acpi_physical_address           address;
+        struct acpi_table_header        table_header;
+        u32                             i;
+
+        ACPI_FUNCTION_TRACE ("ex_load_op");
+
+
+        /* Object can be either an op_region or a Field */
+
+        switch (ACPI_GET_OBJECT_TYPE (obj_desc)) {
+        case ACPI_TYPE_REGION:
+
+                ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Load from Region %p %s\n",
+                        obj_desc, acpi_ut_get_object_type_name (obj_desc)));
+
+                /*
+                 * If the Region Address and Length have not been previously evaluated,
+                 * evaluate them now and save the results.
+                 */
+                if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) {
+                        status = acpi_ds_get_region_arguments (obj_desc);
+                        if (ACPI_FAILURE (status)) {
+                                return_ACPI_STATUS (status);
+                        }
+                }
+
+                /* Get the base physical address of the region */
+
+                address = obj_desc->region.address;
+
+                /* Get the table length from the table header */
+
+                table_header.length = 0;
+                for (i = 0; i < 8; i++) {
+                        status = acpi_ev_address_space_dispatch (obj_desc, ACPI_READ,
+                                           (acpi_physical_address) (i + address), 8,
+                                           ((u8 *) &table_header) + i);
+                        if (ACPI_FAILURE (status)) {
+                                return_ACPI_STATUS (status);
+                        }
+                }
+
+                /* Sanity check the table length */
+
+                if (table_header.length < sizeof (struct acpi_table_header)) {
+                        return_ACPI_STATUS (AE_BAD_HEADER);
+                }
+
+                /* Allocate a buffer for the entire table */
+
+                table_ptr = ACPI_MEM_ALLOCATE (table_header.length);
+                if (!table_ptr) {
+                        return_ACPI_STATUS (AE_NO_MEMORY);
+                }
+
+                /* Get the entire table from the op region */
+
+                for (i = 0; i < table_header.length; i++) {
+                        status = acpi_ev_address_space_dispatch (obj_desc, ACPI_READ,
+                                           (acpi_physical_address) (i + address), 8,
+                                           ((u8 *) table_ptr + i));
+                        if (ACPI_FAILURE (status)) {
+                                goto cleanup;
+                        }
+                }
+                break;
+
+
+        case ACPI_TYPE_LOCAL_REGION_FIELD:
+        case ACPI_TYPE_LOCAL_BANK_FIELD:
+        case ACPI_TYPE_LOCAL_INDEX_FIELD:
+
+                ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Load from Field %p %s\n",
+                        obj_desc, acpi_ut_get_object_type_name (obj_desc)));
+
+                /*
+                 * The length of the field must be at least as large as the table.
+                 * Read the entire field and thus the entire table.  Buffer is
+                 * allocated during the read.
+                 */
+                status = acpi_ex_read_data_from_field (walk_state, obj_desc, &buffer_desc);
+                if (ACPI_FAILURE (status)) {
+                        goto cleanup;
+                }
+
+                table_ptr = ACPI_CAST_PTR (struct acpi_table_header, buffer_desc->buffer.pointer);
+
+                 /* Sanity check the table length */
+
+                if (table_ptr->length < sizeof (struct acpi_table_header)) {
+                        return_ACPI_STATUS (AE_BAD_HEADER);
+                }
+                break;
+
+
+        default:
+                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
+        }
+
+        /* The table must be either an SSDT or a PSDT */
+
+        if ((!ACPI_STRNCMP (table_ptr->signature,
+                          acpi_gbl_table_data[ACPI_TABLE_PSDT].signature,
+                          acpi_gbl_table_data[ACPI_TABLE_PSDT].sig_length)) &&
+                (!ACPI_STRNCMP (table_ptr->signature,
+                                 acpi_gbl_table_data[ACPI_TABLE_SSDT].signature,
+                                 acpi_gbl_table_data[ACPI_TABLE_SSDT].sig_length))) {
+                ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
+                        "Table has invalid signature [%4.4s], must be SSDT or PSDT\n",
+                        table_ptr->signature));
+                status = AE_BAD_SIGNATURE;
+                goto cleanup;
+        }
+
+        /* Install the new table into the local data structures */
+
+        status = acpi_ex_add_table (table_ptr, acpi_gbl_root_node, &ddb_handle);
+        if (ACPI_FAILURE (status)) {
+                goto cleanup;
+        }
+
+        /* Store the ddb_handle into the Target operand */
+
+        status = acpi_ex_store (ddb_handle, target, walk_state);
+        if (ACPI_FAILURE (status)) {
+                (void) acpi_ex_unload_table (ddb_handle);
+        }
+
+        return_ACPI_STATUS (status);
+
+
+cleanup:
+
+        if (buffer_desc) {
+                acpi_ut_remove_reference (buffer_desc);
+        }
+        else {
+                ACPI_MEM_FREE (table_ptr);
+        }
+        return_ACPI_STATUS (status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ex_unload_table
+ *
+ * PARAMETERS:  ddb_handle          - Handle to a previously loaded table
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Unload an ACPI table
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_ex_unload_table (
+        union acpi_operand_object       *ddb_handle)
+{
+        acpi_status                     status = AE_OK;
+        union acpi_operand_object       *table_desc = ddb_handle;
+        struct acpi_table_desc          *table_info;
+
+
+        ACPI_FUNCTION_TRACE ("ex_unload_table");
+
+
+        /*
+         * Validate the handle
+         * Although the handle is partially validated in acpi_ex_reconfiguration(),
+         * when it calls acpi_ex_resolve_operands(), the handle is more completely
+         * validated here.
+         */
+        if ((!ddb_handle) ||
+                (ACPI_GET_DESCRIPTOR_TYPE (ddb_handle) != ACPI_DESC_TYPE_OPERAND) ||
+                (ACPI_GET_OBJECT_TYPE (ddb_handle) != ACPI_TYPE_LOCAL_REFERENCE)) {
+                return_ACPI_STATUS (AE_BAD_PARAMETER);
+        }
+
+        /* Get the actual table descriptor from the ddb_handle */
+
+        table_info = (struct acpi_table_desc *) table_desc->reference.object;
+
+        /*
+         * Delete the entire namespace under this table Node
+         * (Offset contains the table_id)
+         */
+        acpi_ns_delete_namespace_by_owner (table_info->table_id);
+
+        /* Delete the table itself */
+
+        (void) acpi_tb_uninstall_table (table_info->installed_desc);
+
+        /* Delete the table descriptor (ddb_handle) */
+
+        acpi_ut_remove_reference (table_desc);
+        return_ACPI_STATUS (status);
+}
+