/****************************************************************************** * * Module Name: tbinstal - ACPI table installation and removal * *****************************************************************************/ /* * Copyright (C) 2000 - 2007, 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/acnamesp.h> #include <acpi/actables.h> #define _COMPONENT ACPI_TABLES ACPI_MODULE_NAME("tbinstal") /****************************************************************************** * * FUNCTION: acpi_tb_verify_table * * PARAMETERS: table_desc - table * * RETURN: Status * * DESCRIPTION: this function is called to verify and map table * *****************************************************************************/ acpi_status acpi_tb_verify_table(struct acpi_table_desc *table_desc) { acpi_status status = AE_OK; ACPI_FUNCTION_TRACE(tb_verify_table); /* Map the table if necessary */ if (!table_desc->pointer) { if ((table_desc->flags & ACPI_TABLE_ORIGIN_MASK) == ACPI_TABLE_ORIGIN_MAPPED) { table_desc->pointer = acpi_os_map_memory(table_desc->address, table_desc->length); } if (!table_desc->pointer) { return_ACPI_STATUS(AE_NO_MEMORY); } } /* FACS is the odd table, has no standard ACPI header and no checksum */ if (!ACPI_COMPARE_NAME(&table_desc->signature, ACPI_SIG_FACS)) { /* Always calculate checksum, ignore bad checksum if requested */ status = acpi_tb_verify_checksum(table_desc->pointer, table_desc->length); } return_ACPI_STATUS(status); } /******************************************************************************* * * FUNCTION: acpi_tb_add_table * * PARAMETERS: table_desc - Table descriptor * table_index - Where the table index is returned * * RETURN: Status * * DESCRIPTION: This function is called to add the ACPI table * ******************************************************************************/ acpi_status acpi_tb_add_table(struct acpi_table_desc *table_desc, acpi_native_uint * table_index) { acpi_native_uint i; acpi_native_uint length; acpi_status status = AE_OK; ACPI_FUNCTION_TRACE(tb_add_table); if (!table_desc->pointer) { status = acpi_tb_verify_table(table_desc); if (ACPI_FAILURE(status) || !table_desc->pointer) { return_ACPI_STATUS(status); } } /* The table must be either an SSDT or a PSDT or an OEMx */ if ((!ACPI_COMPARE_NAME(table_desc->pointer->signature, ACPI_SIG_PSDT)) && (!ACPI_COMPARE_NAME(table_desc->pointer->signature, ACPI_SIG_SSDT)) && (strncmp(table_desc->pointer->signature, "OEM", 3))) { ACPI_ERROR((AE_INFO, "Table has invalid signature [%4.4s], must be SSDT, PSDT or OEMx", table_desc->pointer->signature)); return_ACPI_STATUS(AE_BAD_SIGNATURE); } (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); /* Check if table is already registered */ for (i = 0; i < acpi_gbl_root_table_list.count; ++i) { if (!acpi_gbl_root_table_list.tables[i].pointer) { status = acpi_tb_verify_table(&acpi_gbl_root_table_list. tables[i]); if (ACPI_FAILURE(status) || !acpi_gbl_root_table_list.tables[i].pointer) { continue; } } length = ACPI_MIN(table_desc->length, acpi_gbl_root_table_list.tables[i].length); if (ACPI_MEMCMP(table_desc->pointer, acpi_gbl_root_table_list.tables[i].pointer, length)) { continue; } /* Table is already registered */ acpi_tb_delete_table(table_desc); *table_index = i; goto release; } /* * Add the table to the global table list */ status = acpi_tb_store_table(table_desc->address, table_desc->pointer, table_desc->length, table_desc->flags, table_index); if (ACPI_FAILURE(status)) { goto release; } acpi_tb_print_table_header(table_desc->address, table_desc->pointer); release: (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); return_ACPI_STATUS(status); } /******************************************************************************* * * FUNCTION: acpi_tb_resize_root_table_list * * PARAMETERS: None * * RETURN: Status * * DESCRIPTION: Expand the size of global table array * ******************************************************************************/ acpi_status acpi_tb_resize_root_table_list(void) { struct acpi_table_desc *tables; ACPI_FUNCTION_TRACE(tb_resize_root_table_list); /* allow_resize flag is a parameter to acpi_initialize_tables */ if (!(acpi_gbl_root_table_list.flags & ACPI_ROOT_ALLOW_RESIZE)) { ACPI_ERROR((AE_INFO, "Resize of Root Table Array is not allowed")); return_ACPI_STATUS(AE_SUPPORT); } /* Increase the Table Array size */ tables = ACPI_ALLOCATE_ZEROED((acpi_gbl_root_table_list.size + ACPI_ROOT_TABLE_SIZE_INCREMENT) * sizeof(struct acpi_table_desc)); if (!tables) { ACPI_ERROR((AE_INFO, "Could not allocate new root table array")); return_ACPI_STATUS(AE_NO_MEMORY); } /* Copy and free the previous table array */ if (acpi_gbl_root_table_list.tables) { ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables, acpi_gbl_root_table_list.size * sizeof(struct acpi_table_desc)); if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) { ACPI_FREE(acpi_gbl_root_table_list.tables); } } acpi_gbl_root_table_list.tables = tables; acpi_gbl_root_table_list.size += ACPI_ROOT_TABLE_SIZE_INCREMENT; acpi_gbl_root_table_list.flags |= (u8) ACPI_ROOT_ORIGIN_ALLOCATED; return_ACPI_STATUS(AE_OK); } /******************************************************************************* * * FUNCTION: acpi_tb_store_table * * PARAMETERS: Address - Table address * Table - Table header * Length - Table length * Flags - flags * * RETURN: Status and table index. * * DESCRIPTION: Add an ACPI table to the global table list * ******************************************************************************/ acpi_status acpi_tb_store_table(acpi_physical_address address, struct acpi_table_header *table, u32 length, u8 flags, acpi_native_uint * table_index) { acpi_status status = AE_OK; /* Ensure that there is room for the table in the Root Table List */ if (acpi_gbl_root_table_list.count >= acpi_gbl_root_table_list.size) { status = acpi_tb_resize_root_table_list(); if (ACPI_FAILURE(status)) { return (status); } } /* Initialize added table */ acpi_gbl_root_table_list.tables[acpi_gbl_root_table_list.count]. address = address; acpi_gbl_root_table_list.tables[acpi_gbl_root_table_list.count]. pointer = table; acpi_gbl_root_table_list.tables[acpi_gbl_root_table_list.count].length = length; acpi_gbl_root_table_list.tables[acpi_gbl_root_table_list.count]. owner_id = 0; acpi_gbl_root_table_list.tables[acpi_gbl_root_table_list.count].flags = flags; ACPI_MOVE_32_TO_32(& (acpi_gbl_root_table_list. tables[acpi_gbl_root_table_list.count].signature), table->signature); *table_index = acpi_gbl_root_table_list.count; acpi_gbl_root_table_list.count++; return (status); } /******************************************************************************* * * FUNCTION: acpi_tb_delete_table * * PARAMETERS: table_index - Table index * * RETURN: None * * DESCRIPTION: Delete one internal ACPI table * ******************************************************************************/ void acpi_tb_delete_table(struct acpi_table_desc *table_desc) { /* Table must be mapped or allocated */ if (!table_desc->pointer) { return; } switch (table_desc->flags & ACPI_TABLE_ORIGIN_MASK) { case ACPI_TABLE_ORIGIN_MAPPED: acpi_os_unmap_memory(table_desc->pointer, table_desc->length); break; case ACPI_TABLE_ORIGIN_ALLOCATED: ACPI_FREE(table_desc->pointer); break; default:; } table_desc->pointer = NULL; } /******************************************************************************* * * FUNCTION: acpi_tb_terminate * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Delete all internal ACPI tables * ******************************************************************************/ void acpi_tb_terminate(void) { acpi_native_uint i; ACPI_FUNCTION_TRACE(tb_terminate); (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); /* Delete the individual tables */ for (i = 0; i < acpi_gbl_root_table_list.count; ++i) { acpi_tb_delete_table(&acpi_gbl_root_table_list.tables[i]); } /* * Delete the root table array if allocated locally. Array cannot be * mapped, so we don't need to check for that flag. */ if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) { ACPI_FREE(acpi_gbl_root_table_list.tables); } acpi_gbl_root_table_list.tables = NULL; acpi_gbl_root_table_list.flags = 0; acpi_gbl_root_table_list.count = 0; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "ACPI Tables freed\n")); (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); } /******************************************************************************* * * FUNCTION: acpi_tb_delete_namespace_by_owner * * PARAMETERS: table_index - Table index * * RETURN: None * * DESCRIPTION: Delete all namespace objects created when this table was loaded. * ******************************************************************************/ void acpi_tb_delete_namespace_by_owner(acpi_native_uint table_index) { acpi_owner_id owner_id; (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); if (table_index < acpi_gbl_root_table_list.count) { owner_id = acpi_gbl_root_table_list.tables[table_index].owner_id; } else { (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); return; } (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); acpi_ns_delete_namespace_by_owner(owner_id); } /******************************************************************************* * * FUNCTION: acpi_tb_allocate_owner_id * * PARAMETERS: table_index - Table index * * RETURN: Status * * DESCRIPTION: Allocates owner_id in table_desc * ******************************************************************************/ acpi_status acpi_tb_allocate_owner_id(acpi_native_uint table_index) { acpi_status status = AE_BAD_PARAMETER; ACPI_FUNCTION_TRACE(tb_allocate_owner_id); (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); if (table_index < acpi_gbl_root_table_list.count) { status = acpi_ut_allocate_owner_id (&(acpi_gbl_root_table_list.tables[table_index].owner_id)); } (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); return_ACPI_STATUS(status); } /******************************************************************************* * * FUNCTION: acpi_tb_release_owner_id * * PARAMETERS: table_index - Table index * * RETURN: Status * * DESCRIPTION: Releases owner_id in table_desc * ******************************************************************************/ acpi_status acpi_tb_release_owner_id(acpi_native_uint table_index) { acpi_status status = AE_BAD_PARAMETER; ACPI_FUNCTION_TRACE(tb_release_owner_id); (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); if (table_index < acpi_gbl_root_table_list.count) { acpi_ut_release_owner_id(& (acpi_gbl_root_table_list. tables[table_index].owner_id)); status = AE_OK; } (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); return_ACPI_STATUS(status); } /******************************************************************************* * * FUNCTION: acpi_tb_get_owner_id * * PARAMETERS: table_index - Table index * owner_id - Where the table owner_id is returned * * RETURN: Status * * DESCRIPTION: returns owner_id for the ACPI table * ******************************************************************************/ acpi_status acpi_tb_get_owner_id(acpi_native_uint table_index, acpi_owner_id * owner_id) { acpi_status status = AE_BAD_PARAMETER; ACPI_FUNCTION_TRACE(tb_get_owner_id); (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); if (table_index < acpi_gbl_root_table_list.count) { *owner_id = acpi_gbl_root_table_list.tables[table_index].owner_id; status = AE_OK; } (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); return_ACPI_STATUS(status); } /******************************************************************************* * * FUNCTION: acpi_tb_is_table_loaded * * PARAMETERS: table_index - Table index * * RETURN: Table Loaded Flag * ******************************************************************************/ u8 acpi_tb_is_table_loaded(acpi_native_uint table_index) { u8 is_loaded = FALSE; (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); if (table_index < acpi_gbl_root_table_list.count) { is_loaded = (u8) (acpi_gbl_root_table_list.tables[table_index]. flags & ACPI_TABLE_IS_LOADED); } (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); return (is_loaded); } /******************************************************************************* * * FUNCTION: acpi_tb_set_table_loaded_flag * * PARAMETERS: table_index - Table index * is_loaded - TRUE if table is loaded, FALSE otherwise * * RETURN: None * * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE. * ******************************************************************************/ void acpi_tb_set_table_loaded_flag(acpi_native_uint table_index, u8 is_loaded) { (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); if (table_index < acpi_gbl_root_table_list.count) { if (is_loaded) { acpi_gbl_root_table_list.tables[table_index].flags |= ACPI_TABLE_IS_LOADED; } else { acpi_gbl_root_table_list.tables[table_index].flags &= ~ACPI_TABLE_IS_LOADED; } } (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); }