1 /******************************************************************************
3 * Module Name: tbxface - Public interfaces to the ACPI subsystem
4 * ACPI table oriented interfaces
6 *****************************************************************************/
9 * Copyright (C) 2000 - 2006, R. Byron Moore
10 * All rights reserved.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
45 #include <acpi/acpi.h>
46 #include <acpi/acnamesp.h>
47 #include <acpi/actables.h>
49 #define _COMPONENT ACPI_TABLES
50 ACPI_MODULE_NAME("tbxface")
52 /* Local prototypes */
53 static acpi_status acpi_tb_load_namespace(void);
55 /*******************************************************************************
57 * FUNCTION: acpi_allocate_root_table
59 * PARAMETERS: initial_table_count - Size of initial_table_array, in number of
60 * struct acpi_table_desc structures
64 * DESCRIPTION: Allocate a root table array. Used by i_aSL compiler and
65 * acpi_initialize_tables.
67 ******************************************************************************/
69 acpi_status acpi_allocate_root_table(u32 initial_table_count)
72 acpi_gbl_root_table_list.size = initial_table_count;
73 acpi_gbl_root_table_list.flags = ACPI_ROOT_ALLOW_RESIZE;
75 return (acpi_tb_resize_root_table_list());
78 /*******************************************************************************
80 * FUNCTION: acpi_initialize_tables
82 * PARAMETERS: initial_table_array - Pointer to an array of pre-allocated
83 * struct acpi_table_desc structures. If NULL, the
84 * array is dynamically allocated.
85 * initial_table_count - Size of initial_table_array, in number of
86 * struct acpi_table_desc structures
87 * allow_realloc - Flag to tell Table Manager if resize of
88 * pre-allocated array is allowed. Ignored
89 * if initial_table_array is NULL.
93 * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT.
95 * NOTE: Allows static allocation of the initial table array in order
96 * to avoid the use of dynamic memory in confined environments
97 * such as the kernel boot sequence where it may not be available.
99 * If the host OS memory managers are initialized, use NULL for
100 * initial_table_array, and the table will be dynamically allocated.
102 ******************************************************************************/
105 acpi_initialize_tables(struct acpi_table_desc * initial_table_array,
106 u32 initial_table_count, u8 allow_resize)
108 acpi_physical_address rsdp_address;
111 ACPI_FUNCTION_TRACE(acpi_initialize_tables);
114 * Set up the Root Table Array
115 * Allocate the table array if requested
117 if (!initial_table_array) {
118 status = acpi_allocate_root_table(initial_table_count);
119 if (ACPI_FAILURE(status)) {
120 return_ACPI_STATUS(status);
123 /* Root Table Array has been statically allocated by the host */
125 ACPI_MEMSET(initial_table_array, 0,
126 initial_table_count *
127 sizeof(struct acpi_table_desc));
129 acpi_gbl_root_table_list.tables = initial_table_array;
130 acpi_gbl_root_table_list.size = initial_table_count;
131 acpi_gbl_root_table_list.flags = ACPI_ROOT_ORIGIN_UNKNOWN;
133 acpi_gbl_root_table_list.flags |=
134 ACPI_ROOT_ALLOW_RESIZE;
138 /* Get the address of the RSDP */
140 rsdp_address = acpi_os_get_root_pointer();
142 return_ACPI_STATUS(AE_NOT_FOUND);
146 * Get the root table (RSDT or XSDT) and extract all entries to the local
147 * Root Table Array. This array contains the information of the RSDT/XSDT
148 * in a common, more useable format.
151 acpi_tb_parse_root_table(rsdp_address, ACPI_TABLE_ORIGIN_MAPPED);
152 return_ACPI_STATUS(status);
155 /*******************************************************************************
157 * FUNCTION: acpi_reallocate_root_table
163 * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the
164 * root list from the previously provided scratch area. Should
165 * be called once dynamic memory allocation is available in the
168 ******************************************************************************/
169 acpi_status acpi_reallocate_root_table(void)
171 struct acpi_table_desc *tables;
174 ACPI_FUNCTION_TRACE(acpi_reallocate_root_table);
177 * Only reallocate the root table if the host provided a static buffer
178 * for the table array in the call to acpi_initialize_tables.
180 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
181 return_ACPI_STATUS(AE_SUPPORT);
185 (acpi_gbl_root_table_list.count +
186 ACPI_ROOT_TABLE_SIZE_INCREMENT) * sizeof(struct acpi_table_desc);
188 /* Create new array and copy the old array */
190 tables = ACPI_ALLOCATE_ZEROED(new_size);
192 return_ACPI_STATUS(AE_NO_MEMORY);
195 ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables, new_size);
197 acpi_gbl_root_table_list.size = acpi_gbl_root_table_list.count;
198 acpi_gbl_root_table_list.tables = tables;
199 acpi_gbl_root_table_list.flags =
200 ACPI_ROOT_ORIGIN_ALLOCATED | ACPI_ROOT_ALLOW_RESIZE;
202 return_ACPI_STATUS(AE_OK);
204 /*******************************************************************************
206 * FUNCTION: acpi_load_table
208 * PARAMETERS: table_ptr - pointer to a buffer containing the entire
213 * DESCRIPTION: This function is called to load a table from the caller's
214 * buffer. The buffer must contain an entire ACPI Table including
215 * a valid header. The header fields will be verified, and if it
216 * is determined that the table is invalid, the call will fail.
218 ******************************************************************************/
219 acpi_status acpi_load_table(struct acpi_table_header *table_ptr)
222 acpi_native_uint table_index;
225 * Install the new table into the local data structures
227 status = acpi_tb_add_table(table_ptr, &table_index);
228 if (ACPI_FAILURE(status)) {
229 return_ACPI_STATUS(status);
231 status = acpi_ns_load_table(table_index, acpi_gbl_root_node);
232 return_ACPI_STATUS(status);
235 ACPI_EXPORT_SYMBOL(acpi_load_table)
237 /******************************************************************************
239 * FUNCTION: acpi_get_table_header
241 * PARAMETERS: Signature - ACPI signature of needed table
242 * Instance - Which instance (for SSDTs)
243 * out_table_header - Where the pointer to the table header
246 * RETURN: Status and pointer to mapped table header
248 * DESCRIPTION: Finds an ACPI table header.
250 * NOTE: Caller is responsible in unmapping the header with
251 * acpi_os_unmap_memory
253 *****************************************************************************/
255 acpi_get_table_header(char *signature,
256 acpi_native_uint instance,
257 struct acpi_table_header **out_table_header)
262 /* Parameter validation */
264 if (!signature || !out_table_header) {
265 return (AE_BAD_PARAMETER);
269 * Walk the root table list
271 for (i = 0, j = 0; i < acpi_gbl_root_table_list.count; i++) {
272 if (!ACPI_COMPARE_NAME
273 (&(acpi_gbl_root_table_list.tables[i].signature),
278 if (++j < instance) {
283 acpi_tb_map(acpi_gbl_root_table_list.tables[i].address,
284 (u32) sizeof(struct acpi_table_header),
285 acpi_gbl_root_table_list.tables[i].
286 flags & ACPI_TABLE_ORIGIN_MASK);
288 if (!(*out_table_header)) {
289 return (AE_NO_MEMORY);
295 return (AE_NOT_FOUND);
298 ACPI_EXPORT_SYMBOL(acpi_get_table_header)
301 /******************************************************************************
303 * FUNCTION: acpi_unload_table_id
305 * PARAMETERS: id - Owner ID of the table to be removed.
309 * DESCRIPTION: This routine is used to force the unload of a table (by id)
311 ******************************************************************************/
312 acpi_status acpi_unload_table_id(acpi_owner_id id)
315 acpi_status status = AE_NOT_EXIST;
317 ACPI_FUNCTION_TRACE(acpi_unload_table);
319 /* Find table from the requested type list */
320 for (i = 0; i < acpi_gbl_root_table_list.count; ++i) {
321 if (id != acpi_gbl_root_table_list.tables[i].owner_id) {
325 * Delete all namespace objects owned by this table. Note that these
326 * objects can appear anywhere in the namespace by virtue of the AML
327 * "Scope" operator. Thus, we need to track ownership by an ID, not
328 * simply a position within the hierarchy
330 acpi_tb_delete_namespace_by_owner(i);
331 acpi_tb_release_owner_id(i);
332 acpi_tb_set_table_loaded_flag(i, FALSE);
334 return_ACPI_STATUS(status);
337 ACPI_EXPORT_SYMBOL(acpi_unload_table_id)
339 /*******************************************************************************
341 * FUNCTION: acpi_get_table
343 * PARAMETERS: Signature - ACPI signature of needed table
344 * Instance - Which instance (for SSDTs)
345 * out_table - Where the pointer to the table is returned
347 * RETURN: Status and pointer to table
349 * DESCRIPTION: Finds and verifies an ACPI table.
351 *****************************************************************************/
353 acpi_get_table(char *signature,
354 acpi_native_uint instance, struct acpi_table_header ** out_table)
360 /* Parameter validation */
362 if (!signature || !out_table) {
363 return (AE_BAD_PARAMETER);
367 * Walk the root table list
369 for (i = 0, j = 0; i < acpi_gbl_root_table_list.count; i++) {
370 if (!ACPI_COMPARE_NAME
371 (&(acpi_gbl_root_table_list.tables[i].signature),
376 if (++j < instance) {
381 acpi_tb_verify_table(&acpi_gbl_root_table_list.tables[i]);
382 if (ACPI_SUCCESS(status)) {
383 *out_table = acpi_gbl_root_table_list.tables[i].pointer;
386 if (!acpi_gbl_permanent_mmap) {
387 acpi_gbl_root_table_list.tables[i].pointer = 0;
393 return (AE_NOT_FOUND);
396 ACPI_EXPORT_SYMBOL(acpi_get_table)
398 /*******************************************************************************
400 * FUNCTION: acpi_get_table_by_index
402 * PARAMETERS: table_index - Table index
403 * Table - Where the pointer to the table is returned
405 * RETURN: Status and pointer to the table
407 * DESCRIPTION: Obtain a table by an index into the global table list.
409 ******************************************************************************/
411 acpi_get_table_by_index(acpi_native_uint table_index,
412 struct acpi_table_header ** table)
416 ACPI_FUNCTION_TRACE(acpi_get_table_by_index);
418 /* Parameter validation */
421 return_ACPI_STATUS(AE_BAD_PARAMETER);
424 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
428 if (table_index >= acpi_gbl_root_table_list.count) {
429 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
430 return_ACPI_STATUS(AE_BAD_PARAMETER);
433 if (!acpi_gbl_root_table_list.tables[table_index].pointer) {
435 /* Table is not mapped, map it */
438 acpi_tb_verify_table(&acpi_gbl_root_table_list.
439 tables[table_index]);
440 if (ACPI_FAILURE(status)) {
441 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
442 return_ACPI_STATUS(status);
446 *table = acpi_gbl_root_table_list.tables[table_index].pointer;
447 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
448 return_ACPI_STATUS(AE_OK);
451 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index)
453 /*******************************************************************************
455 * FUNCTION: acpi_tb_load_namespace
461 * DESCRIPTION: Load the namespace from the DSDT and all SSDTs/PSDTs found in
464 ******************************************************************************/
465 static acpi_status acpi_tb_load_namespace(void)
468 struct acpi_table_header *table;
471 ACPI_FUNCTION_TRACE(tb_load_namespace);
473 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
476 * Load the namespace. The DSDT is required, but any SSDT and PSDT tables
479 if (!acpi_gbl_root_table_list.count ||
481 (acpi_gbl_root_table_list.
482 tables[ACPI_TABLE_INDEX_DSDT].signature),
485 ACPI_FAILURE(acpi_tb_verify_table
486 (&acpi_gbl_root_table_list.
487 tables[ACPI_TABLE_INDEX_DSDT]))) {
488 status = AE_NO_ACPI_TABLES;
489 goto unlock_and_exit;
496 acpi_os_table_override(acpi_gbl_root_table_list.
497 tables[ACPI_TABLE_INDEX_DSDT].pointer,
499 if (ACPI_SUCCESS(status) && table) {
501 * DSDT table has been found
503 acpi_tb_delete_table(ACPI_TABLE_INDEX_DSDT);
504 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].pointer =
506 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].length =
508 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].flags =
509 ACPI_TABLE_ORIGIN_UNKNOWN;
511 ACPI_INFO((AE_INFO, "Table DSDT replaced by host OS"));
512 acpi_tb_print_table_header(0, table);
516 acpi_tb_verify_table(&acpi_gbl_root_table_list.
517 tables[ACPI_TABLE_INDEX_DSDT]);
518 if (ACPI_FAILURE(status)) {
520 /* A valid DSDT is required */
522 status = AE_NO_ACPI_TABLES;
523 goto unlock_and_exit;
526 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
529 * Load and parse tables.
531 status = acpi_ns_load_table(ACPI_TABLE_INDEX_DSDT, acpi_gbl_root_node);
532 if (ACPI_FAILURE(status)) {
533 return_ACPI_STATUS(status);
537 * Load any SSDT or PSDT tables. Note: Loop leaves tables locked
539 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
540 for (i = 0; i < acpi_gbl_root_table_list.count; ++i) {
541 if ((!ACPI_COMPARE_NAME
542 (&(acpi_gbl_root_table_list.tables[i].signature),
546 (acpi_gbl_root_table_list.tables[i].
547 signature), ACPI_SIG_PSDT))
549 ACPI_FAILURE(acpi_tb_verify_table
550 (&acpi_gbl_root_table_list.tables[i]))) {
554 /* Ignore errors while loading tables, get as many as possible */
556 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
557 (void)acpi_ns_load_table(i, acpi_gbl_root_node);
558 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
561 ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI Tables successfully acquired\n"));
564 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
565 return_ACPI_STATUS(status);
568 /*******************************************************************************
570 * FUNCTION: acpi_load_tables
576 * DESCRIPTION: Load the ACPI tables from the RSDT/XSDT
578 ******************************************************************************/
580 acpi_status acpi_load_tables(void)
584 ACPI_FUNCTION_TRACE(acpi_load_tables);
587 * Load the namespace from the tables
589 status = acpi_tb_load_namespace();
590 if (ACPI_FAILURE(status)) {
591 ACPI_EXCEPTION((AE_INFO, status,
592 "While loading namespace from ACPI tables"));
595 return_ACPI_STATUS(status);
598 ACPI_EXPORT_SYMBOL(acpi_load_tables)