1 /******************************************************************************
3 * Module Name: tbxface - ACPI table-oriented external interfaces
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2017, 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 #define EXPORT_ACPI_INTERFACES
46 #include <acpi/acpi.h>
50 #define _COMPONENT ACPI_TABLES
51 ACPI_MODULE_NAME("tbxface")
53 /*******************************************************************************
55 * FUNCTION: acpi_allocate_root_table
57 * PARAMETERS: initial_table_count - Size of initial_table_array, in number of
58 * struct acpi_table_desc structures
62 * DESCRIPTION: Allocate a root table array. Used by iASL compiler and
63 * acpi_initialize_tables.
65 ******************************************************************************/
66 acpi_status acpi_allocate_root_table(u32 initial_table_count)
69 acpi_gbl_root_table_list.max_table_count = initial_table_count;
70 acpi_gbl_root_table_list.flags = ACPI_ROOT_ALLOW_RESIZE;
72 return (acpi_tb_resize_root_table_list());
75 /*******************************************************************************
77 * FUNCTION: acpi_initialize_tables
79 * PARAMETERS: initial_table_array - Pointer to an array of pre-allocated
80 * struct acpi_table_desc structures. If NULL, the
81 * array is dynamically allocated.
82 * initial_table_count - Size of initial_table_array, in number of
83 * struct acpi_table_desc structures
84 * allow_resize - Flag to tell Table Manager if resize of
85 * pre-allocated array is allowed. Ignored
86 * if initial_table_array is NULL.
90 * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT.
92 * NOTE: Allows static allocation of the initial table array in order
93 * to avoid the use of dynamic memory in confined environments
94 * such as the kernel boot sequence where it may not be available.
96 * If the host OS memory managers are initialized, use NULL for
97 * initial_table_array, and the table will be dynamically allocated.
99 ******************************************************************************/
101 acpi_status ACPI_INIT_FUNCTION
102 acpi_initialize_tables(struct acpi_table_desc *initial_table_array,
103 u32 initial_table_count, u8 allow_resize)
105 acpi_physical_address rsdp_address;
108 ACPI_FUNCTION_TRACE(acpi_initialize_tables);
111 * Setup the Root Table Array and allocate the table array
114 if (!initial_table_array) {
115 status = acpi_allocate_root_table(initial_table_count);
116 if (ACPI_FAILURE(status)) {
117 return_ACPI_STATUS(status);
120 /* Root Table Array has been statically allocated by the host */
122 memset(initial_table_array, 0,
123 (acpi_size)initial_table_count *
124 sizeof(struct acpi_table_desc));
126 acpi_gbl_root_table_list.tables = initial_table_array;
127 acpi_gbl_root_table_list.max_table_count = initial_table_count;
128 acpi_gbl_root_table_list.flags = ACPI_ROOT_ORIGIN_UNKNOWN;
130 acpi_gbl_root_table_list.flags |=
131 ACPI_ROOT_ALLOW_RESIZE;
135 /* Get the address of the RSDP */
137 rsdp_address = acpi_os_get_root_pointer();
139 return_ACPI_STATUS(AE_NOT_FOUND);
143 * Get the root table (RSDT or XSDT) and extract all entries to the local
144 * Root Table Array. This array contains the information of the RSDT/XSDT
145 * in a common, more useable format.
147 status = acpi_tb_parse_root_table(rsdp_address);
148 return_ACPI_STATUS(status);
151 ACPI_EXPORT_SYMBOL_INIT(acpi_initialize_tables)
153 /*******************************************************************************
155 * FUNCTION: acpi_reallocate_root_table
161 * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the
162 * root list from the previously provided scratch area. Should
163 * be called once dynamic memory allocation is available in the
166 ******************************************************************************/
167 acpi_status ACPI_INIT_FUNCTION acpi_reallocate_root_table(void)
170 struct acpi_table_desc *table_desc;
173 ACPI_FUNCTION_TRACE(acpi_reallocate_root_table);
176 * Only reallocate the root table if the host provided a static buffer
177 * for the table array in the call to acpi_initialize_tables.
179 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
180 return_ACPI_STATUS(AE_SUPPORT);
183 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
186 * Ensure OS early boot logic, which is required by some hosts. If the
187 * table state is reported to be wrong, developers should fix the
188 * issue by invoking acpi_put_table() for the reported table during the
191 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) {
192 table_desc = &acpi_gbl_root_table_list.tables[i];
193 if (table_desc->pointer) {
195 "Table [%4.4s] is not invalidated during early boot stage",
196 table_desc->signature.ascii));
200 if (!acpi_gbl_enable_table_validation) {
202 * Now it's safe to do full table validation. We can do deferred
203 * table initilization here once the flag is set.
205 acpi_gbl_enable_table_validation = TRUE;
206 for (i = 0; i < acpi_gbl_root_table_list.current_table_count;
208 table_desc = &acpi_gbl_root_table_list.tables[i];
209 if (!(table_desc->flags & ACPI_TABLE_IS_VERIFIED)) {
211 acpi_tb_verify_temp_table(table_desc, NULL,
213 if (ACPI_FAILURE(status)) {
214 acpi_tb_uninstall_table(table_desc);
220 acpi_gbl_root_table_list.flags |= ACPI_ROOT_ALLOW_RESIZE;
221 status = acpi_tb_resize_root_table_list();
222 acpi_gbl_root_table_list.flags |= ACPI_ROOT_ORIGIN_ALLOCATED;
224 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
225 return_ACPI_STATUS(status);
228 ACPI_EXPORT_SYMBOL_INIT(acpi_reallocate_root_table)
230 /*******************************************************************************
232 * FUNCTION: acpi_get_table_header
234 * PARAMETERS: signature - ACPI signature of needed table
235 * instance - Which instance (for SSDTs)
236 * out_table_header - The pointer to the table header to fill
238 * RETURN: Status and pointer to mapped table header
240 * DESCRIPTION: Finds an ACPI table header.
242 * NOTE: Caller is responsible in unmapping the header with
243 * acpi_os_unmap_memory
245 ******************************************************************************/
247 acpi_get_table_header(char *signature,
248 u32 instance, struct acpi_table_header *out_table_header)
252 struct acpi_table_header *header;
254 /* Parameter validation */
256 if (!signature || !out_table_header) {
257 return (AE_BAD_PARAMETER);
260 /* Walk the root table list */
262 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count;
264 if (!ACPI_COMPARE_NAME
265 (&(acpi_gbl_root_table_list.tables[i].signature),
270 if (++j < instance) {
274 if (!acpi_gbl_root_table_list.tables[i].pointer) {
275 if ((acpi_gbl_root_table_list.tables[i].flags &
276 ACPI_TABLE_ORIGIN_MASK) ==
277 ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL) {
279 acpi_os_map_memory(acpi_gbl_root_table_list.
284 return (AE_NO_MEMORY);
287 memcpy(out_table_header, header,
288 sizeof(struct acpi_table_header));
289 acpi_os_unmap_memory(header,
293 return (AE_NOT_FOUND);
296 memcpy(out_table_header,
297 acpi_gbl_root_table_list.tables[i].pointer,
298 sizeof(struct acpi_table_header));
303 return (AE_NOT_FOUND);
306 ACPI_EXPORT_SYMBOL(acpi_get_table_header)
308 /*******************************************************************************
310 * FUNCTION: acpi_get_table
312 * PARAMETERS: signature - ACPI signature of needed table
313 * instance - Which instance (for SSDTs)
314 * out_table - Where the pointer to the table is returned
316 * RETURN: Status and pointer to the requested table
318 * DESCRIPTION: Finds and verifies an ACPI table. Table must be in the
320 * Note that an early stage acpi_get_table() call must be paired
321 * with an early stage acpi_put_table() call. otherwise the table
322 * pointer mapped by the early stage mapping implementation may be
323 * erroneously unmapped by the late stage unmapping implementation
324 * in an acpi_put_table() invoked during the late stage.
326 ******************************************************************************/
328 acpi_get_table(char *signature,
329 u32 instance, struct acpi_table_header ** out_table)
333 acpi_status status = AE_NOT_FOUND;
334 struct acpi_table_desc *table_desc;
336 /* Parameter validation */
338 if (!signature || !out_table) {
339 return (AE_BAD_PARAMETER);
343 * Note that the following line is required by some OSPMs, they only
344 * check if the returned table is NULL instead of the returned status
345 * to determined if this function is succeeded.
349 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
351 /* Walk the root table list */
353 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count;
355 table_desc = &acpi_gbl_root_table_list.tables[i];
357 if (!ACPI_COMPARE_NAME(&table_desc->signature, signature)) {
361 if (++j < instance) {
365 status = acpi_tb_get_table(table_desc, out_table);
369 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
373 ACPI_EXPORT_SYMBOL(acpi_get_table)
375 /*******************************************************************************
377 * FUNCTION: acpi_put_table
379 * PARAMETERS: table - The pointer to the table
383 * DESCRIPTION: Release a table returned by acpi_get_table() and its clones.
384 * Note that it is not safe if this function was invoked after an
385 * uninstallation happened to the original table descriptor.
386 * Currently there is no OSPMs' requirement to handle such
389 ******************************************************************************/
390 void acpi_put_table(struct acpi_table_header *table)
393 struct acpi_table_desc *table_desc;
395 ACPI_FUNCTION_TRACE(acpi_put_table);
401 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
403 /* Walk the root table list */
405 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) {
406 table_desc = &acpi_gbl_root_table_list.tables[i];
408 if (table_desc->pointer != table) {
412 acpi_tb_put_table(table_desc);
416 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
420 ACPI_EXPORT_SYMBOL(acpi_put_table)
422 /*******************************************************************************
424 * FUNCTION: acpi_get_table_by_index
426 * PARAMETERS: table_index - Table index
427 * out_table - Where the pointer to the table is returned
429 * RETURN: Status and pointer to the requested table
431 * DESCRIPTION: Obtain a table by an index into the global table list. Used
434 ******************************************************************************/
436 acpi_get_table_by_index(u32 table_index, struct acpi_table_header **out_table)
440 ACPI_FUNCTION_TRACE(acpi_get_table_by_index);
442 /* Parameter validation */
445 return_ACPI_STATUS(AE_BAD_PARAMETER);
449 * Note that the following line is required by some OSPMs, they only
450 * check if the returned table is NULL instead of the returned status
451 * to determined if this function is succeeded.
455 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
459 if (table_index >= acpi_gbl_root_table_list.current_table_count) {
460 status = AE_BAD_PARAMETER;
461 goto unlock_and_exit;
465 acpi_tb_get_table(&acpi_gbl_root_table_list.tables[table_index],
469 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
470 return_ACPI_STATUS(status);
473 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index)
475 /*******************************************************************************
477 * FUNCTION: acpi_install_table_handler
479 * PARAMETERS: handler - Table event handler
480 * context - Value passed to the handler on each event
484 * DESCRIPTION: Install a global table event handler.
486 ******************************************************************************/
488 acpi_install_table_handler(acpi_table_handler handler, void *context)
492 ACPI_FUNCTION_TRACE(acpi_install_table_handler);
495 return_ACPI_STATUS(AE_BAD_PARAMETER);
498 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
499 if (ACPI_FAILURE(status)) {
500 return_ACPI_STATUS(status);
503 /* Don't allow more than one handler */
505 if (acpi_gbl_table_handler) {
506 status = AE_ALREADY_EXISTS;
510 /* Install the handler */
512 acpi_gbl_table_handler = handler;
513 acpi_gbl_table_handler_context = context;
516 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
517 return_ACPI_STATUS(status);
520 ACPI_EXPORT_SYMBOL(acpi_install_table_handler)
522 /*******************************************************************************
524 * FUNCTION: acpi_remove_table_handler
526 * PARAMETERS: handler - Table event handler that was installed
531 * DESCRIPTION: Remove a table event handler
533 ******************************************************************************/
534 acpi_status acpi_remove_table_handler(acpi_table_handler handler)
538 ACPI_FUNCTION_TRACE(acpi_remove_table_handler);
540 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
541 if (ACPI_FAILURE(status)) {
542 return_ACPI_STATUS(status);
545 /* Make sure that the installed handler is the same */
547 if (!handler || handler != acpi_gbl_table_handler) {
548 status = AE_BAD_PARAMETER;
552 /* Remove the handler */
554 acpi_gbl_table_handler = NULL;
557 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
558 return_ACPI_STATUS(status);
561 ACPI_EXPORT_SYMBOL(acpi_remove_table_handler)