ACPICA: Implement simplified Table Manager

The Table Manager component has been completely
redesigned and reimplemented. The new design is much
simpler, and reduces the overall code and data size of
the kernel-resident ACPICA by approximately 5%. Also,
it is now possible to obtain the ACPI tables very early
during kernel initialization, even before dynamic memory
management is initialized.

Signed-off-by: Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>

1 files changed, 406 insertions, 194 deletions

diff --git a/drivers/acpi/tables/tbutils.c b/drivers/acpi/tables/tbutils.c
index 209a401801e3..3620ac5f8681 100644
--- a/drivers/acpi/tables/tbutils.c
+++ b/drivers/acpi/tables/tbutils.c
@@ -1,6 +1,6 @@
 /******************************************************************************
  *
- * Module Name: tbutils - Table manipulation utilities
+ * Module Name: tbutils   - table utilities
  *
  *****************************************************************************/
 
@@ -48,295 +48,507 @@
 ACPI_MODULE_NAME("tbutils")
 
 /* Local prototypes */
-#ifdef ACPI_OBSOLETE_FUNCTIONS
-acpi_status
-acpi_tb_handle_to_object(u16 table_id, struct acpi_table_desc **table_desc);
-#endif
+static void acpi_tb_parse_fadt(struct acpi_table_fadt *fadt, u8 flags);
+
+static void inline
+acpi_tb_init_generic_address(struct acpi_generic_address *new_gas_struct,
+                             u8 bit_width, acpi_physical_address address);
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_tb_is_table_installed
+ * FUNCTION:    acpi_tb_print_table_header
  *
- * PARAMETERS:  new_table_desc      - Descriptor for new table being installed
+ * PARAMETERS:  Address             - Table physical address
+ *              Header              - Table header
  *
- * RETURN:      Status - AE_ALREADY_EXISTS if the table is already installed
+ * RETURN:      None
  *
- * DESCRIPTION: Determine if an ACPI table is already installed
- *
- * MUTEX:       Table data structures should be locked
+ * DESCRIPTION: Print an ACPI table header
  *
  ******************************************************************************/
 
-acpi_status acpi_tb_is_table_installed(struct acpi_table_desc *new_table_desc)
+void
+acpi_tb_print_table_header(acpi_physical_address address,
+                           struct acpi_table_header *header)
 {
-        struct acpi_table_desc *table_desc;
-
-        ACPI_FUNCTION_TRACE(tb_is_table_installed);
-
-        /* Get the list descriptor and first table descriptor */
-
-        table_desc = acpi_gbl_table_lists[new_table_desc->type].next;
-
-        /* Examine all installed tables of this type */
-
-        while (table_desc) {
-                /*
-                 * If the table lengths match, perform a full bytewise compare. This
-                 * means that we will allow tables with duplicate oem_table_id(s), as
-                 * long as the tables are different in some way.
-                 *
-                 * Checking if the table has been loaded into the namespace means that
-                 * we don't check for duplicate tables during the initial installation
-                 * of tables within the RSDT/XSDT.
-                 */
-                if ((table_desc->loaded_into_namespace) &&
-                    (table_desc->pointer->length ==
-                     new_table_desc->pointer->length)
-                    &&
-                    (!ACPI_MEMCMP
-                     (table_desc->pointer, new_table_desc->pointer,
-                      new_table_desc->pointer->length))) {
-
-                        /* Match: this table is already installed */
-
-                        ACPI_DEBUG_PRINT((ACPI_DB_TABLES,
-                                          "Table [%4.4s] already installed: Rev %X OemTableId [%8.8s]\n",
-                                          new_table_desc->pointer->signature,
-                                          new_table_desc->pointer->revision,
-                                          new_table_desc->pointer->
-                                          oem_table_id));
-
-                        new_table_desc->owner_id = table_desc->owner_id;
-                        new_table_desc->installed_desc = table_desc;
-
-                        return_ACPI_STATUS(AE_ALREADY_EXISTS);
-                }
-
-                /* Get next table on the list */
 
-                table_desc = table_desc->next;
-        }
-
-        return_ACPI_STATUS(AE_OK);
+        ACPI_INFO((AE_INFO,
+                   "%4.4s @ 0x%p Length 0x%04X (v%3.3d %6.6s %8.8s 0x%08X %4.4s 0x%08X)",
+                   header->signature, ACPI_CAST_PTR(void, address),
+                   header->length, header->revision, header->oem_id,
+                   header->oem_table_id, header->oem_revision,
+                   header->asl_compiler_id, header->asl_compiler_revision));
 }
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_tb_validate_table_header
- *
- * PARAMETERS:  table_header        - Logical pointer to the table
+ * FUNCTION:    acpi_tb_init_generic_address
  *
- * RETURN:      Status
+ * PARAMETERS:  new_gas_struct      - GAS struct to be initialized
+ *              bit_width           - Width of this register
+ *              Address             - Address of the register
  *
- * DESCRIPTION: Check an ACPI table header for validity
+ * RETURN:      None
  *
- * NOTE:  Table pointers are validated as follows:
- *          1) Table pointer must point to valid physical memory
- *          2) Signature must be 4 ASCII chars, even if we don't recognize the
- *             name
- *          3) Table must be readable for length specified in the header
- *          4) Table checksum must be valid (with the exception of the FACS
- *              which has no checksum because it contains variable fields)
+ * DESCRIPTION: Initialize a GAS structure.
  *
  ******************************************************************************/
 
-acpi_status
-acpi_tb_validate_table_header(struct acpi_table_header *table_header)
+static void inline
+acpi_tb_init_generic_address(struct acpi_generic_address *new_gas_struct,
+                             u8 bit_width, acpi_physical_address address)
 {
-        acpi_name signature;
-
-        ACPI_FUNCTION_ENTRY();
-
-        /* Verify that this is a valid address */
-
-        if (!acpi_os_readable(table_header, sizeof(struct acpi_table_header))) {
-                ACPI_ERROR((AE_INFO,
-                            "Cannot read table header at %p", table_header));
-
-                return (AE_BAD_ADDRESS);
-        }
-
-        /* Ensure that the signature is 4 ASCII characters */
-
-        ACPI_MOVE_32_TO_32(&signature, table_header->signature);
-        if (!acpi_ut_valid_acpi_name(signature)) {
-                ACPI_ERROR((AE_INFO, "Invalid table signature 0x%8.8X",
-                            signature));
 
-                ACPI_DUMP_BUFFER(table_header,
-                                 sizeof(struct acpi_table_header));
-                return (AE_BAD_SIGNATURE);
-        }
-
-        /* Validate the table length */
-
-        if (table_header->length < sizeof(struct acpi_table_header)) {
-                ACPI_ERROR((AE_INFO,
-                            "Invalid length 0x%X in table with signature %4.4s",
-                            (u32) table_header->length,
-                            ACPI_CAST_PTR(char, &signature)));
-
-                ACPI_DUMP_BUFFER(table_header,
-                                 sizeof(struct acpi_table_header));
-                return (AE_BAD_HEADER);
-        }
-
-        return (AE_OK);
+        ACPI_STORE_ADDRESS(new_gas_struct->address, address);
+        new_gas_struct->space_id = ACPI_ADR_SPACE_SYSTEM_IO;
+        new_gas_struct->bit_width = bit_width;
+        new_gas_struct->bit_offset = 0;
+        new_gas_struct->access_width = 0;
 }
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_tb_sum_table
+ * FUNCTION:    acpi_tb_checksum
  *
- * PARAMETERS:  Buffer              - Buffer to sum
- *              Length              - Size of the buffer
+ * PARAMETERS:  Buffer          - Pointer to memory region to be checked
+ *              Length          - Length of this memory region
  *
- * RETURN:      8 bit sum of buffer
+ * RETURN:      Checksum (u8)
  *
- * DESCRIPTION: Computes an 8 bit sum of the buffer(length) and returns it.
+ * DESCRIPTION: Calculates circular checksum of memory region.
  *
  ******************************************************************************/
 
-u8 acpi_tb_sum_table(void *buffer, u32 length)
+u8 acpi_tb_checksum(u8 * buffer, acpi_native_uint length)
 {
-        acpi_native_uint i;
         u8 sum = 0;
+        u8 *end = buffer + length;
 
-        if (!buffer || !length) {
-                return (0);
+        while (buffer < end) {
+                sum = (u8) (sum + *(buffer++));
         }
 
-        for (i = 0; i < length; i++) {
-                sum = (u8) (sum + ((u8 *) buffer)[i]);
-        }
-        return (sum);
+        return sum;
 }
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_tb_generate_checksum
+ * FUNCTION:    acpi_tb_convert_fadt
  *
- * PARAMETERS:  Table               - Pointer to a valid ACPI table (with a
- *                                    standard ACPI header)
+ * PARAMETERS:  Fadt                - FADT table to be converted
  *
- * RETURN:      8 bit checksum of buffer
+ * RETURN:      None
  *
- * DESCRIPTION: Computes an 8 bit checksum of the table.
+ * DESCRIPTION: Converts a BIOS supplied ACPI 1.0 FADT to a local
+ *              ACPI 2.0 FADT. If the BIOS supplied a 2.0 FADT then it is simply
+ *              copied to the local FADT.  The ACPI CA software uses this
+ *              local FADT. Thus a significant amount of special #ifdef
+ *              type codeing is saved.
  *
  ******************************************************************************/
 
-u8 acpi_tb_generate_checksum(struct acpi_table_header * table)
+void acpi_tb_convert_fadt(struct acpi_table_fadt *fadt)
 {
-        u8 checksum;
-
-        /* Sum the entire table as-is */
 
-        checksum = acpi_tb_sum_table(table, table->length);
+        /*
+         * Convert table pointers to 64-bit fields
+         */
+        if (!acpi_gbl_FADT.Xfacs) {
+                acpi_gbl_FADT.Xfacs = (u64) acpi_gbl_FADT.facs;
+        }
 
-        /* Subtract off the existing checksum value in the table */
+        if (!acpi_gbl_FADT.Xdsdt) {
+                acpi_gbl_FADT.Xdsdt = (u64) acpi_gbl_FADT.dsdt;
+        }
 
-        checksum = (u8) (checksum - table->checksum);
+        /*
+         * Convert the V1.0 block addresses to V2.0 GAS structures
+         */
+        acpi_tb_init_generic_address(&acpi_gbl_FADT.xpm1a_event_block,
+                                     acpi_gbl_FADT.pm1_event_length,
+                                     (acpi_physical_address) acpi_gbl_FADT.
+                                     pm1a_event_block);
+        acpi_tb_init_generic_address(&acpi_gbl_FADT.xpm1b_event_block,
+                                     acpi_gbl_FADT.pm1_event_length,
+                                     (acpi_physical_address) acpi_gbl_FADT.
+                                     pm1b_event_block);
+        acpi_tb_init_generic_address(&acpi_gbl_FADT.xpm1a_control_block,
+                                     acpi_gbl_FADT.pm1_control_length,
+                                     (acpi_physical_address) acpi_gbl_FADT.
+                                     pm1a_control_block);
+        acpi_tb_init_generic_address(&acpi_gbl_FADT.xpm1b_control_block,
+                                     acpi_gbl_FADT.pm1_control_length,
+                                     (acpi_physical_address) acpi_gbl_FADT.
+                                     pm1b_control_block);
+        acpi_tb_init_generic_address(&acpi_gbl_FADT.xpm2_control_block,
+                                     acpi_gbl_FADT.pm2_control_length,
+                                     (acpi_physical_address) acpi_gbl_FADT.
+                                     pm2_control_block);
+        acpi_tb_init_generic_address(&acpi_gbl_FADT.xpm_timer_block,
+                                     acpi_gbl_FADT.pm_timer_length,
+                                     (acpi_physical_address) acpi_gbl_FADT.
+                                     pm_timer_block);
+        acpi_tb_init_generic_address(&acpi_gbl_FADT.xgpe0_block, 0,
+                                     (acpi_physical_address) acpi_gbl_FADT.
+                                     gpe0_block);
+        acpi_tb_init_generic_address(&acpi_gbl_FADT.xgpe1_block, 0,
+                                     (acpi_physical_address) acpi_gbl_FADT.
+                                     gpe1_block);
+
+        /*
+         * Create separate GAS structs for the PM1 Enable registers
+         */
+        acpi_tb_init_generic_address(&acpi_gbl_xpm1a_enable,
+                                     (u8) ACPI_DIV_2(acpi_gbl_FADT.
+                                                     pm1_event_length),
+                                     (acpi_physical_address)
+                                     (acpi_gbl_FADT.xpm1a_event_block.address +
+                                      ACPI_DIV_2(acpi_gbl_FADT.
+                                                 pm1_event_length)));
+
+        /*
+         * PM1B is optional; leave null if not present
+         */
+        if (acpi_gbl_FADT.xpm1b_event_block.address) {
+                acpi_tb_init_generic_address(&acpi_gbl_xpm1b_enable,
+                                             (u8) ACPI_DIV_2(acpi_gbl_FADT.
+                                                             pm1_event_length),
+                                             (acpi_physical_address)
+                                             (acpi_gbl_FADT.xpm1b_event_block.
+                                              address +
+                                              ACPI_DIV_2(acpi_gbl_FADT.
+                                                         pm1_event_length)));
+        }
 
-        /* Compute the final checksum */
+        /* Global FADT is the new common V2.0 FADT  */
 
-        checksum = (u8) (0 - checksum);
-        return (checksum);
+        acpi_gbl_FADT.header.length = sizeof(struct acpi_table_fadt);
 }
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_tb_set_checksum
+ * FUNCTION:    acpi_tb_parse_fadt
  *
- * PARAMETERS:  Table               - Pointer to a valid ACPI table (with a
- *                                    standard ACPI header)
+ * PARAMETERS:  Fadt                - Pointer to FADT table
+ *              Flags               - Flags
  *
- * RETURN:      None. Sets the table checksum field
+ * RETURN:      none
  *
- * DESCRIPTION: Computes an 8 bit checksum of the table and inserts the
- *              checksum into the table header.
+ * DESCRIPTION: This function is called to initialise the FADT, DSDT and FACS
+ *              tables (FADT contains the addresses of the DSDT and FACS)
  *
  ******************************************************************************/
 
-void acpi_tb_set_checksum(struct acpi_table_header *table)
+static void acpi_tb_parse_fadt(struct acpi_table_fadt *fadt, u8 flags)
 {
+        acpi_physical_address dsdt_address =
+            (acpi_physical_address) fadt->Xdsdt;
+        acpi_physical_address facs_address =
+            (acpi_physical_address) fadt->Xfacs;
+        struct acpi_table_header *table;
+
+        if (!dsdt_address) {
+                goto no_dsdt;
+        }
+
+        table =
+            acpi_os_map_memory(dsdt_address, sizeof(struct acpi_table_header));
+        if (!table) {
+                goto no_dsdt;
+        }
+
+        /* Initialize the DSDT table */
+
+        ACPI_MOVE_32_TO_32(&
+                           (acpi_gbl_root_table_list.
+                            tables[ACPI_TABLE_INDEX_DSDT].signature),
+                           ACPI_SIG_DSDT);
+
+        acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].address =
+            dsdt_address;
+        acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].length =
+            table->length;
+        acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].flags = flags;
+
+        acpi_tb_print_table_header(dsdt_address, table);
+
+        /* Global integer width is based upon revision of the DSDT */
+
+        acpi_ut_set_integer_width(table->revision);
+        acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));
+
+      no_dsdt:
+        if (!facs_address) {
+                return;
+        }
 
-        table->checksum = acpi_tb_generate_checksum(table);
+        table =
+            acpi_os_map_memory(facs_address, sizeof(struct acpi_table_header));
+        if (!table) {
+                return;
+        }
+
+        /* Initialize the FACS table */
+
+        ACPI_MOVE_32_TO_32(&
+                           (acpi_gbl_root_table_list.
+                            tables[ACPI_TABLE_INDEX_FACS].signature),
+                           ACPI_SIG_FACS);
+
+        acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_FACS].address =
+            facs_address;
+        acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_FACS].length =
+            table->length;
+        acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_FACS].flags = flags;
+
+        ACPI_INFO((AE_INFO, "%4.4s @ 0x%p",
+                   table->signature, ACPI_CAST_PTR(void, facs_address)));
+
+        acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));
 }
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_tb_verify_table_checksum
+ * FUNCTION:    acpi_tb_parse_root_table
  *
- * PARAMETERS:  *table_header           - ACPI table to verify
+ * PARAMETERS:  Rsdp                    - Pointer to the RSDP
+ *              Flags                   - Flags
+ *
+ * RETURN:      Status
  *
- * RETURN:      8 bit checksum of table
+ * DESCRIPTION: This function is called to parse the Root System Description
+ *              Table (RSDT or XSDT)
  *
- * DESCRIPTION: Generates an 8 bit checksum of table and returns and compares
- *              it to the existing checksum value.
+ * NOTE:        Tables are mapped (not copied) for efficiency. The FACS must
+ *              be mapped and cannot be copied because it contains the actual
+ *              memory location of the ACPI Global Lock.
  *
  ******************************************************************************/
 
-acpi_status
-acpi_tb_verify_table_checksum(struct acpi_table_header *table_header)
+acpi_status acpi_tb_parse_root_table(struct acpi_table_rsdp *rsdp, u8 flags)
 {
+        struct acpi_table_header *table;
+        acpi_physical_address address;
+        u32 length;
+        u8 *table_entry;
+        acpi_native_uint i;
+        acpi_native_uint pointer_size;
+        u32 table_count;
         u8 checksum;
+        acpi_status status;
+
+        ACPI_FUNCTION_TRACE(tb_parse_root_table);
+
+        /* Differentiate between RSDT and XSDT root tables */
+
+        if (rsdp->revision > 1 && rsdp->xsdt_physical_address) {
+                /*
+                 * Root table is an XSDT (64-bit physical addresses). We must use the
+                 * XSDT if the revision is > 1 and the XSDT pointer is present, as per
+                 * the ACPI specification.
+                 */
+                address = (acpi_native_uint) rsdp->xsdt_physical_address;
+                pointer_size = sizeof(u64);
+        } else {
+                /* Root table is an RSDT (32-bit physical addresses) */
+
+                address = (acpi_native_uint) rsdp->rsdt_physical_address;
+                pointer_size = sizeof(u32);
+        }
 
-        ACPI_FUNCTION_TRACE(tb_verify_table_checksum);
+        /* Map the table header to get the full table length */
 
-        /* Compute the checksum on the table */
+        table = acpi_os_map_memory(address, sizeof(struct acpi_table_header));
+        if (!table) {
+                return (AE_NO_MEMORY);
+        }
+
+        /* Get the length of the full table, verify length and map entire table */
+
+        length = table->length;
+        acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));
+
+        if (length < sizeof(struct acpi_table_header)) {
+                ACPI_ERROR((AE_INFO, "Invalid length 0x%X in RSDT/XSDT",
+                            length));
+                return (AE_INVALID_TABLE_LENGTH);
+        }
+
+        table = acpi_os_map_memory(address, length);
+        if (!table) {
+                return (AE_NO_MEMORY);
+        }
+
+        /* Validate the root table checksum */
+
+        checksum = acpi_tb_checksum(ACPI_CAST_PTR(u8, table), length);
+#if (ACPI_CHECKSUM_ABORT)
+
+        if (checksum) {
+                acpi_os_unmap_memory(table, length);
+                return (AE_BAD_CHECKSUM);
+        }
+#endif
+
+        acpi_tb_print_table_header(address, table);
+
+        /* Calculate the number of tables described in the root table */
+
+        table_count =
+            (table->length - sizeof(struct acpi_table_header)) / pointer_size;
+
+        /* Setup loop */
 
-        checksum = acpi_tb_generate_checksum(table_header);
+        table_entry =
+            ACPI_CAST_PTR(u8, table) + sizeof(struct acpi_table_header);
+        acpi_gbl_root_table_list.count = 2;
 
-        /* Checksum ok? */
+        /*
+         * Initialize the ACPI table entries
+         * First two entries in the table array are reserved for the DSDT and FACS
+         */
+        for (i = 0; i < table_count; ++i, table_entry += pointer_size) {
 
-        if (checksum == table_header->checksum) {
-                return_ACPI_STATUS(AE_OK);
+                /* Ensure there is room for another table entry */
+
+                if (acpi_gbl_root_table_list.count >=
+                    acpi_gbl_root_table_list.size) {
+                        status = acpi_tb_resize_root_table_list();
+                        if (ACPI_FAILURE(status)) {
+                                ACPI_WARNING((AE_INFO,
+                                              "Truncating %u table entries!",
+                                              (unsigned)
+                                              (acpi_gbl_root_table_list.size -
+                                               acpi_gbl_root_table_list.
+                                               count)));
+                                break;
+                        }
+                }
+
+                /* Get the physical address (32-bit for RSDT, 64-bit for XSDT) */
+
+                if (pointer_size == sizeof(u32)) {
+                        acpi_gbl_root_table_list.
+                            tables[acpi_gbl_root_table_list.count].address =
+                            (acpi_physical_address) (*ACPI_CAST_PTR
+                                                     (u32, table_entry));
+                } else {
+                        acpi_gbl_root_table_list.
+                            tables[acpi_gbl_root_table_list.count].address =
+                            (acpi_physical_address) (*ACPI_CAST_PTR
+                                                     (u64, table_entry));
+                }
+
+                acpi_gbl_root_table_list.count++;
         }
 
-        ACPI_WARNING((AE_INFO,
-                      "Incorrect checksum in table [%4.4s] - is %2.2X, should be %2.2X",
-                      table_header->signature, table_header->checksum,
-                      checksum));
+        /*
+         * It is not possible to map more than one entry in some environments,
+         * so unmap the root table here before mapping other tables
+         */
+        acpi_os_unmap_memory(table, length);
+
+        /* Initialize all tables other than the DSDT and FACS */
+
+        for (i = 2; i < acpi_gbl_root_table_list.count; i++) {
+                address = acpi_gbl_root_table_list.tables[i].address;
+                length = sizeof(struct acpi_table_header);
+
+                table = acpi_os_map_memory(address, length);
+                if (!table) {
+                        continue;
+                }
+
+                acpi_gbl_root_table_list.tables[i].length = table->length;
+                acpi_gbl_root_table_list.tables[i].flags = flags;
+
+                ACPI_MOVE_32_TO_32(&
+                                   (acpi_gbl_root_table_list.tables[i].
+                                    signature), table->signature);
+
+                acpi_tb_print_table_header(address, table);
+
+                /*
+                 * Special case for the FADT because of multiple versions -
+                 * get a local copy and convert to common format
+                 */
+                if (ACPI_COMPARE_NAME(table->signature, ACPI_SIG_FADT)) {
+                        acpi_os_unmap_memory(table, length);
+                        length = table->length;
+
+                        table = acpi_os_map_memory(address, length);
+                        if (!table) {
+                                continue;
+                        }
+
+                        /* Copy the entire FADT locally */
+
+                        ACPI_MEMCPY(&acpi_gbl_FADT, table,
+                                    ACPI_MIN(table->length,
+                                             sizeof(struct acpi_table_fadt)));
+
+                        /* Small table means old revision, convert to new */
+
+                        if (table->length < sizeof(struct acpi_table_fadt)) {
+                                acpi_tb_convert_fadt(ACPI_CAST_PTR
+                                                     (struct acpi_table_fadt,
+                                                      table));
+                        }
+
+                        /* Unmap original FADT */
 
-        return_ACPI_STATUS(AE_BAD_CHECKSUM);
+                        acpi_os_unmap_memory(table, length);
+                        acpi_tb_parse_fadt(&acpi_gbl_FADT, flags);
+                } else {
+                        acpi_os_unmap_memory(table, length);
+                }
+        }
+
+        return_ACPI_STATUS(AE_OK);
 }
 
-#ifdef ACPI_OBSOLETE_FUNCTIONS
-/*******************************************************************************
+/******************************************************************************
  *
- * FUNCTION:    acpi_tb_handle_to_object
+ * FUNCTION:    acpi_tb_map
  *
- * PARAMETERS:  table_id            - Id for which the function is searching
- *              table_desc          - Pointer to return the matching table
- *                                      descriptor.
+ * PARAMETERS:  Address             - Address to be mapped
+ *              Length              - Length to be mapped
+ *              Flags               - Logical or physical addressing mode
  *
- * RETURN:      Search the tables to find one with a matching table_id and
- *              return a pointer to that table descriptor.
+ * RETURN:      Pointer to mapped region
  *
- ******************************************************************************/
+ * DESCRIPTION: Maps memory according to flag
+ *
+ *****************************************************************************/
 
-acpi_status
-acpi_tb_handle_to_object(u16 table_id,
-                         struct acpi_table_desc **return_table_desc)
+void *acpi_tb_map(acpi_physical_address address, u32 length, u32 flags)
 {
-        u32 i;
-        struct acpi_table_desc *table_desc;
 
-        ACPI_FUNCTION_NAME(tb_handle_to_object);
+        if (flags == ACPI_TABLE_ORIGIN_MAPPED) {
+                return (acpi_os_map_memory(address, length));
+        } else {
+                return (ACPI_CAST_PTR(void, address));
+        }
+}
 
-        for (i = 0; i < ACPI_TABLE_MAX; i++) {
-                table_desc = acpi_gbl_table_lists[i].next;
-                while (table_desc) {
-                        if (table_desc->table_id == table_id) {
-                                *return_table_desc = table_desc;
-                                return (AE_OK);
-                        }
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_unmap
+ *
+ * PARAMETERS:  Pointer             - To mapped region
+ *              Length              - Length to be unmapped
+ *              Flags               - Logical or physical addressing mode
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Unmaps memory according to flag
+ *
+ *****************************************************************************/
 
-                        table_desc = table_desc->next;
-                }
-        }
+void acpi_tb_unmap(void *pointer, u32 length, u32 flags)
+{
 
-        ACPI_ERROR((AE_INFO, "TableId=%X does not exist", table_id));
-        return (AE_BAD_PARAMETER);
+        if (flags == ACPI_TABLE_ORIGIN_MAPPED) {
+                acpi_os_unmap_memory(pointer, length);
+        }
 }
-#endif