1 /******************************************************************************
3 * Module Name: tbinstal - ACPI table installation and removal
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2014, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
44 #include <acpi/acpi.h>
49 #define _COMPONENT ACPI_TABLES
50 ACPI_MODULE_NAME("tbinstal")
52 /******************************************************************************
54 * FUNCTION: acpi_tb_verify_table
56 * PARAMETERS: table_desc - table
60 * DESCRIPTION: this function is called to verify and map table
62 *****************************************************************************/
63 acpi_status acpi_tb_verify_table(struct acpi_table_desc *table_desc)
65 acpi_status status = AE_OK;
67 ACPI_FUNCTION_TRACE(tb_verify_table);
69 /* Map the table if necessary */
71 if (!table_desc->pointer) {
72 if ((table_desc->flags & ACPI_TABLE_ORIGIN_MASK) ==
73 ACPI_TABLE_ORIGIN_MAPPED) {
75 acpi_os_map_memory(table_desc->address,
78 if (!table_desc->pointer) {
79 return_ACPI_STATUS(AE_NO_MEMORY);
83 /* Always calculate checksum, ignore bad checksum if requested */
86 acpi_tb_verify_checksum(table_desc->pointer, table_desc->length);
88 return_ACPI_STATUS(status);
91 /*******************************************************************************
93 * FUNCTION: acpi_tb_add_table
95 * PARAMETERS: table_desc - Table descriptor
96 * table_index - Where the table index is returned
100 * DESCRIPTION: This function is called to add an ACPI table. It is used to
101 * dynamically load tables via the Load and load_table AML
104 ******************************************************************************/
107 acpi_tb_add_table(struct acpi_table_desc *table_desc, u32 *table_index)
110 acpi_status status = AE_OK;
112 ACPI_FUNCTION_TRACE(tb_add_table);
114 if (!table_desc->pointer) {
115 status = acpi_tb_verify_table(table_desc);
116 if (ACPI_FAILURE(status) || !table_desc->pointer) {
117 return_ACPI_STATUS(status);
122 * Validate the incoming table signature.
124 * 1) Originally, we checked the table signature for "SSDT" or "PSDT".
125 * 2) We added support for OEMx tables, signature "OEM".
126 * 3) Valid tables were encountered with a null signature, so we just
127 * gave up on validating the signature, (05/2008).
128 * 4) We encountered non-AML tables such as the MADT, which caused
129 * interpreter errors and kernel faults. So now, we once again allow
130 * only "SSDT", "OEMx", and now, also a null signature. (05/2011).
132 if ((table_desc->pointer->signature[0] != 0x00) &&
133 (!ACPI_COMPARE_NAME(table_desc->pointer->signature, ACPI_SIG_SSDT))
134 && (ACPI_STRNCMP(table_desc->pointer->signature, "OEM", 3))) {
135 ACPI_BIOS_ERROR((AE_INFO,
136 "Table has invalid signature [%4.4s] (0x%8.8X), "
137 "must be SSDT or OEMx",
138 acpi_ut_valid_acpi_name(table_desc->pointer->
140 table_desc->pointer->signature : "????",
141 *(u32 *)table_desc->pointer->signature));
143 return_ACPI_STATUS(AE_BAD_SIGNATURE);
146 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
148 /* Check if table is already registered */
150 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) {
151 if (!acpi_gbl_root_table_list.tables[i].pointer) {
153 acpi_tb_verify_table(&acpi_gbl_root_table_list.
155 if (ACPI_FAILURE(status)
156 || !acpi_gbl_root_table_list.tables[i].pointer) {
162 * Check for a table match on the entire table length,
163 * not just the header.
165 if (table_desc->length !=
166 acpi_gbl_root_table_list.tables[i].length) {
170 if (ACPI_MEMCMP(table_desc->pointer,
171 acpi_gbl_root_table_list.tables[i].pointer,
172 acpi_gbl_root_table_list.tables[i].length)) {
177 * Note: the current mechanism does not unregister a table if it is
178 * dynamically unloaded. The related namespace entries are deleted,
179 * but the table remains in the root table list.
181 * The assumption here is that the number of different tables that
182 * will be loaded is actually small, and there is minimal overhead
183 * in just keeping the table in case it is needed again.
185 * If this assumption changes in the future (perhaps on large
186 * machines with many table load/unload operations), tables will
187 * need to be unregistered when they are unloaded, and slots in the
188 * root table list should be reused when empty.
192 * Table is already registered.
193 * We can delete the table that was passed as a parameter.
195 acpi_tb_delete_table(table_desc);
198 if (acpi_gbl_root_table_list.tables[i].
199 flags & ACPI_TABLE_IS_LOADED) {
201 /* Table is still loaded, this is an error */
203 status = AE_ALREADY_EXISTS;
206 /* Table was unloaded, allow it to be reloaded */
208 table_desc->pointer =
209 acpi_gbl_root_table_list.tables[i].pointer;
210 table_desc->address =
211 acpi_gbl_root_table_list.tables[i].address;
218 * ACPI Table Override:
219 * Allow the host to override dynamically loaded tables.
220 * NOTE: the table is fully mapped at this point, and the mapping will
221 * be deleted by tb_table_override if the table is actually overridden.
223 (void)acpi_tb_table_override(table_desc->pointer, table_desc);
225 /* Add the table to the global root table list */
227 status = acpi_tb_store_table(table_desc->address, table_desc->pointer,
228 table_desc->length, table_desc->flags,
230 if (ACPI_FAILURE(status)) {
235 acpi_tb_print_table_header(table_desc->address, table_desc->pointer);
238 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
239 return_ACPI_STATUS(status);
242 /*******************************************************************************
244 * FUNCTION: acpi_tb_table_override
246 * PARAMETERS: table_header - Header for the original table
247 * table_desc - Table descriptor initialized for the
248 * original table. May or may not be mapped.
250 * RETURN: Pointer to the entire new table. NULL if table not overridden.
251 * If overridden, installs the new table within the input table
254 * DESCRIPTION: Attempt table override by calling the OSL override functions.
255 * Note: If the table is overridden, then the entire new table
256 * is mapped and returned by this function.
258 ******************************************************************************/
260 struct acpi_table_header *acpi_tb_table_override(struct acpi_table_header
262 struct acpi_table_desc
266 struct acpi_table_header *new_table = NULL;
267 acpi_physical_address new_address = 0;
268 u32 new_table_length = 0;
272 /* (1) Attempt logical override (returns a logical address) */
274 status = acpi_os_table_override(table_header, &new_table);
275 if (ACPI_SUCCESS(status) && new_table) {
276 new_address = ACPI_PTR_TO_PHYSADDR(new_table);
277 new_table_length = new_table->length;
278 new_flags = ACPI_TABLE_ORIGIN_OVERRIDE;
279 override_type = "Logical";
280 goto finish_override;
283 /* (2) Attempt physical override (returns a physical address) */
285 status = acpi_os_physical_table_override(table_header,
288 if (ACPI_SUCCESS(status) && new_address && new_table_length) {
290 /* Map the entire new table */
292 new_table = acpi_os_map_memory(new_address, new_table_length);
294 ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY,
295 "%4.4s " ACPI_PRINTF_UINT
296 " Attempted physical table override failed",
297 table_header->signature,
298 ACPI_FORMAT_TO_UINT(table_desc->
303 override_type = "Physical";
304 new_flags = ACPI_TABLE_ORIGIN_MAPPED;
305 goto finish_override;
308 return (NULL); /* There was no override */
312 ACPI_INFO((AE_INFO, "%4.4s " ACPI_PRINTF_UINT
313 " %s table override, new table: " ACPI_PRINTF_UINT,
314 table_header->signature,
315 ACPI_FORMAT_TO_UINT(table_desc->address),
316 override_type, ACPI_FORMAT_TO_UINT(new_table)));
318 /* We can now unmap/delete the original table (if fully mapped) */
320 acpi_tb_delete_table(table_desc);
322 /* Setup descriptor for the new table */
324 table_desc->address = new_address;
325 table_desc->pointer = new_table;
326 table_desc->length = new_table_length;
327 table_desc->flags = new_flags;
332 /*******************************************************************************
334 * FUNCTION: acpi_tb_resize_root_table_list
340 * DESCRIPTION: Expand the size of global table array
342 ******************************************************************************/
344 acpi_status acpi_tb_resize_root_table_list(void)
346 struct acpi_table_desc *tables;
349 ACPI_FUNCTION_TRACE(tb_resize_root_table_list);
351 /* allow_resize flag is a parameter to acpi_initialize_tables */
353 if (!(acpi_gbl_root_table_list.flags & ACPI_ROOT_ALLOW_RESIZE)) {
355 "Resize of Root Table Array is not allowed"));
356 return_ACPI_STATUS(AE_SUPPORT);
359 /* Increase the Table Array size */
361 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
362 table_count = acpi_gbl_root_table_list.max_table_count;
364 table_count = acpi_gbl_root_table_list.current_table_count;
367 tables = ACPI_ALLOCATE_ZEROED(((acpi_size) table_count +
368 ACPI_ROOT_TABLE_SIZE_INCREMENT) *
369 sizeof(struct acpi_table_desc));
372 "Could not allocate new root table array"));
373 return_ACPI_STATUS(AE_NO_MEMORY);
376 /* Copy and free the previous table array */
378 if (acpi_gbl_root_table_list.tables) {
379 ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables,
380 (acpi_size) table_count *
381 sizeof(struct acpi_table_desc));
383 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
384 ACPI_FREE(acpi_gbl_root_table_list.tables);
388 acpi_gbl_root_table_list.tables = tables;
389 acpi_gbl_root_table_list.max_table_count =
390 table_count + ACPI_ROOT_TABLE_SIZE_INCREMENT;
391 acpi_gbl_root_table_list.flags |= ACPI_ROOT_ORIGIN_ALLOCATED;
393 return_ACPI_STATUS(AE_OK);
396 /*******************************************************************************
398 * FUNCTION: acpi_tb_store_table
400 * PARAMETERS: address - Table address
401 * table - Table header
402 * length - Table length
405 * RETURN: Status and table index.
407 * DESCRIPTION: Add an ACPI table to the global table list
409 ******************************************************************************/
412 acpi_tb_store_table(acpi_physical_address address,
413 struct acpi_table_header *table,
414 u32 length, u8 flags, u32 *table_index)
417 struct acpi_table_desc *new_table;
419 /* Ensure that there is room for the table in the Root Table List */
421 if (acpi_gbl_root_table_list.current_table_count >=
422 acpi_gbl_root_table_list.max_table_count) {
423 status = acpi_tb_resize_root_table_list();
424 if (ACPI_FAILURE(status)) {
430 &acpi_gbl_root_table_list.tables[acpi_gbl_root_table_list.
431 current_table_count];
433 /* Initialize added table */
435 new_table->address = address;
436 new_table->pointer = table;
437 new_table->length = length;
438 new_table->owner_id = 0;
439 new_table->flags = flags;
441 ACPI_MOVE_32_TO_32(&new_table->signature, table->signature);
443 *table_index = acpi_gbl_root_table_list.current_table_count;
444 acpi_gbl_root_table_list.current_table_count++;
448 /*******************************************************************************
450 * FUNCTION: acpi_tb_delete_table
452 * PARAMETERS: table_index - Table index
456 * DESCRIPTION: Delete one internal ACPI table
458 ******************************************************************************/
460 void acpi_tb_delete_table(struct acpi_table_desc *table_desc)
462 /* Table must be mapped or allocated */
463 if (!table_desc->pointer) {
466 switch (table_desc->flags & ACPI_TABLE_ORIGIN_MASK) {
467 case ACPI_TABLE_ORIGIN_MAPPED:
469 acpi_os_unmap_memory(table_desc->pointer, table_desc->length);
472 case ACPI_TABLE_ORIGIN_ALLOCATED:
474 ACPI_FREE(table_desc->pointer);
477 /* Not mapped or allocated, there is nothing we can do */
484 table_desc->pointer = NULL;
487 /*******************************************************************************
489 * FUNCTION: acpi_tb_terminate
495 * DESCRIPTION: Delete all internal ACPI tables
497 ******************************************************************************/
499 void acpi_tb_terminate(void)
503 ACPI_FUNCTION_TRACE(tb_terminate);
505 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
507 /* Delete the individual tables */
509 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) {
510 acpi_tb_delete_table(&acpi_gbl_root_table_list.tables[i]);
514 * Delete the root table array if allocated locally. Array cannot be
515 * mapped, so we don't need to check for that flag.
517 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
518 ACPI_FREE(acpi_gbl_root_table_list.tables);
521 acpi_gbl_root_table_list.tables = NULL;
522 acpi_gbl_root_table_list.flags = 0;
523 acpi_gbl_root_table_list.current_table_count = 0;
525 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "ACPI Tables freed\n"));
526 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
531 /*******************************************************************************
533 * FUNCTION: acpi_tb_delete_namespace_by_owner
535 * PARAMETERS: table_index - Table index
539 * DESCRIPTION: Delete all namespace objects created when this table was loaded.
541 ******************************************************************************/
543 acpi_status acpi_tb_delete_namespace_by_owner(u32 table_index)
545 acpi_owner_id owner_id;
548 ACPI_FUNCTION_TRACE(tb_delete_namespace_by_owner);
550 status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
551 if (ACPI_FAILURE(status)) {
552 return_ACPI_STATUS(status);
555 if (table_index >= acpi_gbl_root_table_list.current_table_count) {
557 /* The table index does not exist */
559 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
560 return_ACPI_STATUS(AE_NOT_EXIST);
563 /* Get the owner ID for this table, used to delete namespace nodes */
565 owner_id = acpi_gbl_root_table_list.tables[table_index].owner_id;
566 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
569 * Need to acquire the namespace writer lock to prevent interference
570 * with any concurrent namespace walks. The interpreter must be
571 * released during the deletion since the acquisition of the deletion
572 * lock may block, and also since the execution of a namespace walk
573 * must be allowed to use the interpreter.
575 (void)acpi_ut_release_mutex(ACPI_MTX_INTERPRETER);
576 status = acpi_ut_acquire_write_lock(&acpi_gbl_namespace_rw_lock);
578 acpi_ns_delete_namespace_by_owner(owner_id);
579 if (ACPI_FAILURE(status)) {
580 return_ACPI_STATUS(status);
583 acpi_ut_release_write_lock(&acpi_gbl_namespace_rw_lock);
585 status = acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER);
586 return_ACPI_STATUS(status);
589 /*******************************************************************************
591 * FUNCTION: acpi_tb_allocate_owner_id
593 * PARAMETERS: table_index - Table index
597 * DESCRIPTION: Allocates owner_id in table_desc
599 ******************************************************************************/
601 acpi_status acpi_tb_allocate_owner_id(u32 table_index)
603 acpi_status status = AE_BAD_PARAMETER;
605 ACPI_FUNCTION_TRACE(tb_allocate_owner_id);
607 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
608 if (table_index < acpi_gbl_root_table_list.current_table_count) {
609 status = acpi_ut_allocate_owner_id
610 (&(acpi_gbl_root_table_list.tables[table_index].owner_id));
613 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
614 return_ACPI_STATUS(status);
617 /*******************************************************************************
619 * FUNCTION: acpi_tb_release_owner_id
621 * PARAMETERS: table_index - Table index
625 * DESCRIPTION: Releases owner_id in table_desc
627 ******************************************************************************/
629 acpi_status acpi_tb_release_owner_id(u32 table_index)
631 acpi_status status = AE_BAD_PARAMETER;
633 ACPI_FUNCTION_TRACE(tb_release_owner_id);
635 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
636 if (table_index < acpi_gbl_root_table_list.current_table_count) {
637 acpi_ut_release_owner_id(&
638 (acpi_gbl_root_table_list.
639 tables[table_index].owner_id));
643 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
644 return_ACPI_STATUS(status);
647 /*******************************************************************************
649 * FUNCTION: acpi_tb_get_owner_id
651 * PARAMETERS: table_index - Table index
652 * owner_id - Where the table owner_id is returned
656 * DESCRIPTION: returns owner_id for the ACPI table
658 ******************************************************************************/
660 acpi_status acpi_tb_get_owner_id(u32 table_index, acpi_owner_id *owner_id)
662 acpi_status status = AE_BAD_PARAMETER;
664 ACPI_FUNCTION_TRACE(tb_get_owner_id);
666 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
667 if (table_index < acpi_gbl_root_table_list.current_table_count) {
669 acpi_gbl_root_table_list.tables[table_index].owner_id;
673 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
674 return_ACPI_STATUS(status);
677 /*******************************************************************************
679 * FUNCTION: acpi_tb_is_table_loaded
681 * PARAMETERS: table_index - Table index
683 * RETURN: Table Loaded Flag
685 ******************************************************************************/
687 u8 acpi_tb_is_table_loaded(u32 table_index)
689 u8 is_loaded = FALSE;
691 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
692 if (table_index < acpi_gbl_root_table_list.current_table_count) {
694 (acpi_gbl_root_table_list.tables[table_index].flags &
695 ACPI_TABLE_IS_LOADED);
698 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
702 /*******************************************************************************
704 * FUNCTION: acpi_tb_set_table_loaded_flag
706 * PARAMETERS: table_index - Table index
707 * is_loaded - TRUE if table is loaded, FALSE otherwise
711 * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE.
713 ******************************************************************************/
715 void acpi_tb_set_table_loaded_flag(u32 table_index, u8 is_loaded)
718 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
719 if (table_index < acpi_gbl_root_table_list.current_table_count) {
721 acpi_gbl_root_table_list.tables[table_index].flags |=
722 ACPI_TABLE_IS_LOADED;
724 acpi_gbl_root_table_list.tables[table_index].flags &=
725 ~ACPI_TABLE_IS_LOADED;
729 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);