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_initialize_tables
59 * PARAMETERS: initial_table_array - Pointer to an array of pre-allocated
60 * struct acpi_table_desc structures. If NULL, the
61 * array is dynamically allocated.
62 * initial_table_count - Size of initial_table_array, in number of
63 * struct acpi_table_desc structures
64 * allow_realloc - Flag to tell Table Manager if resize of
65 * pre-allocated array is allowed. Ignored
66 * if initial_table_array is NULL.
70 * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT.
72 * NOTE: Allows static allocation of the initial table array in order
73 * to avoid the use of dynamic memory in confined environments
74 * such as the kernel boot sequence where it may not be available.
76 * If the host OS memory managers are initialized, use NULL for
77 * initial_table_array, and the table will be dynamically allocated.
79 ******************************************************************************/
82 acpi_initialize_tables(struct acpi_table_desc *initial_table_array,
83 u32 initial_table_count, u8 allow_resize)
85 acpi_physical_address rsdp_address;
88 ACPI_FUNCTION_TRACE(acpi_initialize_tables);
91 * Set up the Root Table Array
92 * Allocate the table array if requested
94 if (!initial_table_array) {
95 acpi_gbl_root_table_list.size = initial_table_count;
96 acpi_gbl_root_table_list.flags = ACPI_ROOT_ALLOW_RESIZE;
98 status = acpi_tb_resize_root_table_list();
99 if (ACPI_FAILURE(status)) {
100 return_ACPI_STATUS(status);
103 /* Root Table Array has been statically allocated by the host */
105 ACPI_MEMSET(initial_table_array,
106 initial_table_count *
107 sizeof(struct acpi_table_desc), 0);
109 acpi_gbl_root_table_list.tables = initial_table_array;
110 acpi_gbl_root_table_list.size = initial_table_count;
111 acpi_gbl_root_table_list.flags = ACPI_ROOT_ORIGIN_UNKNOWN;
113 acpi_gbl_root_table_list.flags |=
114 ACPI_ROOT_ALLOW_RESIZE;
118 /* Get the address of the RSDP */
120 rsdp_address = acpi_os_get_root_pointer();
122 return_ACPI_STATUS(AE_NOT_FOUND);
126 * Get the root table (RSDT or XSDT) and extract all entries to the local
127 * Root Table Array. This array contains the information of the RSDT/XSDT
128 * in a common, more useable format.
131 acpi_tb_parse_root_table(rsdp_address, ACPI_TABLE_ORIGIN_MAPPED);
132 return_ACPI_STATUS(status);
135 ACPI_EXPORT_SYMBOL(acpi_initialize_tables)
137 /*******************************************************************************
139 * FUNCTION: acpi_reallocate_root_table
145 * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the
146 * root list from the previously provided scratch area. Should
147 * be called once dynamic memory allocation is available in the
150 ******************************************************************************/
151 acpi_status acpi_reallocate_root_table(void)
153 struct acpi_table_desc *tables;
156 ACPI_FUNCTION_TRACE(acpi_reallocate_root_table);
159 * Only reallocate the root table if the host provided a static buffer
160 * for the table array in the call to acpi_initialize_tables.
162 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
163 return_ACPI_STATUS(AE_SUPPORT);
167 (acpi_gbl_root_table_list.count +
168 ACPI_ROOT_TABLE_SIZE_INCREMENT) * sizeof(struct acpi_table_desc);
170 /* Create new array and copy the old array */
172 tables = ACPI_ALLOCATE_ZEROED(new_size);
174 return_ACPI_STATUS(AE_NO_MEMORY);
177 ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables, new_size);
179 acpi_gbl_root_table_list.size = acpi_gbl_root_table_list.count;
180 acpi_gbl_root_table_list.tables = tables;
181 acpi_gbl_root_table_list.flags =
182 ACPI_ROOT_ORIGIN_ALLOCATED | ACPI_ROOT_ALLOW_RESIZE;
184 return_ACPI_STATUS(AE_OK);
186 /*******************************************************************************
188 * FUNCTION: acpi_load_table
190 * PARAMETERS: table_ptr - pointer to a buffer containing the entire
195 * DESCRIPTION: This function is called to load a table from the caller's
196 * buffer. The buffer must contain an entire ACPI Table including
197 * a valid header. The header fields will be verified, and if it
198 * is determined that the table is invalid, the call will fail.
200 ******************************************************************************/
201 acpi_status acpi_load_table(struct acpi_table_header *table_ptr)
204 acpi_native_uint table_index;
207 * Install the new table into the local data structures
209 status = acpi_tb_add_table(table_ptr, &table_index);
210 if (ACPI_FAILURE(status)) {
211 return_ACPI_STATUS(status);
213 status = acpi_ns_load_table(table_index, acpi_gbl_root_node);
214 return_ACPI_STATUS(status);
217 ACPI_EXPORT_SYMBOL(acpi_load_table)
219 /******************************************************************************
221 * FUNCTION: acpi_get_table_header
223 * PARAMETERS: Signature - ACPI signature of needed table
224 * Instance - Which instance (for SSDTs)
225 * out_table_header - Where the pointer to the table header
228 * RETURN: Status and pointer to mapped table header
230 * DESCRIPTION: Finds an ACPI table header.
232 * NOTE: Caller is responsible in unmapping the header with
233 * acpi_os_unmap_memory
235 *****************************************************************************/
237 acpi_get_table_header(char *signature,
238 acpi_native_uint instance,
239 struct acpi_table_header **out_table_header)
244 /* Parameter validation */
246 if (!signature || !out_table_header) {
247 return (AE_BAD_PARAMETER);
251 * Walk the root table list
253 for (i = 0, j = 0; i < acpi_gbl_root_table_list.count; i++) {
254 if (!ACPI_COMPARE_NAME
255 (&(acpi_gbl_root_table_list.tables[i].signature),
260 if (++j < instance) {
265 acpi_tb_map(acpi_gbl_root_table_list.tables[i].address,
266 (u32) sizeof(struct acpi_table_header),
267 acpi_gbl_root_table_list.tables[i].
268 flags & ACPI_TABLE_ORIGIN_MASK);
270 if (!(*out_table_header)) {
271 return (AE_NO_MEMORY);
277 return (AE_NOT_FOUND);
280 ACPI_EXPORT_SYMBOL(acpi_get_table_header)
283 /******************************************************************************
285 * FUNCTION: acpi_unload_table_id
287 * PARAMETERS: id - Owner ID of the table to be removed.
291 * DESCRIPTION: This routine is used to force the unload of a table (by id)
293 ******************************************************************************/
294 acpi_status acpi_unload_table_id(acpi_owner_id id)
297 acpi_status status = AE_NOT_EXIST;
299 ACPI_FUNCTION_TRACE(acpi_unload_table);
301 /* Find table from the requested type list */
302 for (i = 0; i < acpi_gbl_root_table_list.count; ++i) {
303 if (id != acpi_gbl_root_table_list.tables[i].owner_id) {
307 * Delete all namespace objects owned by this table. Note that these
308 * objects can appear anywhere in the namespace by virtue of the AML
309 * "Scope" operator. Thus, we need to track ownership by an ID, not
310 * simply a position within the hierarchy
312 acpi_tb_delete_namespace_by_owner(i);
313 acpi_tb_release_owner_id(i);
314 acpi_tb_set_table_loaded_flag(i, FALSE);
316 return_ACPI_STATUS(status);
319 ACPI_EXPORT_SYMBOL(acpi_unload_table_id)
321 /*******************************************************************************
323 * FUNCTION: acpi_get_table
325 * PARAMETERS: Signature - ACPI signature of needed table
326 * Instance - Which instance (for SSDTs)
327 * out_table - Where the pointer to the table is returned
329 * RETURN: Status and pointer to table
331 * DESCRIPTION: Finds and verifies an ACPI table.
333 *****************************************************************************/
335 acpi_get_table(char *signature,
336 acpi_native_uint instance, struct acpi_table_header ** out_table)
342 /* Parameter validation */
344 if (!signature || !out_table) {
345 return (AE_BAD_PARAMETER);
349 * Walk the root table list
351 for (i = 0, j = 0; i < acpi_gbl_root_table_list.count; i++) {
352 if (!ACPI_COMPARE_NAME
353 (&(acpi_gbl_root_table_list.tables[i].signature),
358 if (++j < instance) {
363 acpi_tb_verify_table(&acpi_gbl_root_table_list.tables[i]);
364 if (ACPI_SUCCESS(status)) {
365 *out_table = acpi_gbl_root_table_list.tables[i].pointer;
371 return (AE_NOT_FOUND);
374 ACPI_EXPORT_SYMBOL(acpi_get_table)
376 /*******************************************************************************
378 * FUNCTION: acpi_get_table_by_index
380 * PARAMETERS: table_index - Table index
381 * Table - Where the pointer to the table is returned
383 * RETURN: Status and pointer to the table
385 * DESCRIPTION: Obtain a table by an index into the global table list.
387 ******************************************************************************/
389 acpi_get_table_by_index(acpi_native_uint table_index,
390 struct acpi_table_header ** table)
394 ACPI_FUNCTION_TRACE(acpi_get_table_by_index);
396 /* Parameter validation */
399 return_ACPI_STATUS(AE_BAD_PARAMETER);
402 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
406 if (table_index >= acpi_gbl_root_table_list.count) {
407 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
408 return_ACPI_STATUS(AE_BAD_PARAMETER);
411 if (!acpi_gbl_root_table_list.tables[table_index].pointer) {
413 /* Table is not mapped, map it */
416 acpi_tb_verify_table(&acpi_gbl_root_table_list.
417 tables[table_index]);
418 if (ACPI_FAILURE(status)) {
419 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
420 return_ACPI_STATUS(status);
424 *table = acpi_gbl_root_table_list.tables[table_index].pointer;
425 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
426 return_ACPI_STATUS(AE_OK);
429 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index)
431 /*******************************************************************************
433 * FUNCTION: acpi_tb_load_namespace
439 * DESCRIPTION: Load the namespace from the DSDT and all SSDTs/PSDTs found in
442 ******************************************************************************/
443 static acpi_status acpi_tb_load_namespace(void)
446 struct acpi_table_header *table;
449 ACPI_FUNCTION_TRACE(tb_load_namespace);
451 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
454 * Load the namespace. The DSDT is required, but any SSDT and PSDT tables
457 if (!acpi_gbl_root_table_list.count ||
459 (acpi_gbl_root_table_list.
460 tables[ACPI_TABLE_INDEX_DSDT].signature),
463 ACPI_FAILURE(acpi_tb_verify_table
464 (&acpi_gbl_root_table_list.
465 tables[ACPI_TABLE_INDEX_DSDT]))) {
466 status = AE_NO_ACPI_TABLES;
467 goto unlock_and_exit;
474 acpi_os_table_override(acpi_gbl_root_table_list.
475 tables[ACPI_TABLE_INDEX_DSDT].pointer,
477 if (ACPI_SUCCESS(status) && table) {
479 * DSDT table has been found
481 acpi_tb_delete_table(ACPI_TABLE_INDEX_DSDT);
482 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].pointer =
484 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].length =
486 acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].flags =
487 ACPI_TABLE_ORIGIN_UNKNOWN;
489 ACPI_INFO((AE_INFO, "Table DSDT replaced by host OS"));
490 acpi_tb_print_table_header(0, table);
494 acpi_tb_verify_table(&acpi_gbl_root_table_list.
495 tables[ACPI_TABLE_INDEX_DSDT]);
496 if (ACPI_FAILURE(status)) {
498 /* A valid DSDT is required */
500 status = AE_NO_ACPI_TABLES;
501 goto unlock_and_exit;
504 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
507 * Load and parse tables.
509 status = acpi_ns_load_table(ACPI_TABLE_INDEX_DSDT, acpi_gbl_root_node);
510 if (ACPI_FAILURE(status)) {
511 return_ACPI_STATUS(status);
515 * Load any SSDT or PSDT tables. Note: Loop leaves tables locked
517 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
518 for (i = 0; i < acpi_gbl_root_table_list.count; ++i) {
519 if ((!ACPI_COMPARE_NAME
520 (&(acpi_gbl_root_table_list.tables[i].signature),
524 (acpi_gbl_root_table_list.tables[i].
525 signature), ACPI_SIG_PSDT))
527 ACPI_FAILURE(acpi_tb_verify_table
528 (&acpi_gbl_root_table_list.tables[i]))) {
532 /* Ignore errors while loading tables, get as many as possible */
534 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
535 (void)acpi_ns_load_table(i, acpi_gbl_root_node);
536 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
539 ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI Tables successfully acquired\n"));
542 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
543 return_ACPI_STATUS(status);
546 /*******************************************************************************
548 * FUNCTION: acpi_load_tables
554 * DESCRIPTION: Load the ACPI tables from the RSDT/XSDT
556 ******************************************************************************/
558 acpi_status acpi_load_tables(void)
562 ACPI_FUNCTION_TRACE(acpi_load_tables);
565 * Load the namespace from the tables
567 status = acpi_tb_load_namespace();
568 if (ACPI_FAILURE(status)) {
569 ACPI_EXCEPTION((AE_INFO, status,
570 "While loading namespace from ACPI tables"));
573 return_ACPI_STATUS(status);
576 ACPI_EXPORT_SYMBOL(acpi_load_tables)