Linux 4.1.16
[linux/fpc-iii.git] / drivers / acpi / acpica / tbxface.c
blob60e94f87f27aeea917c9705358ea4675666363d9
1 /******************************************************************************
3 * Module Name: tbxface - ACPI table-oriented external interfaces
5 *****************************************************************************/
7 /*
8 * Copyright (C) 2000 - 2015, Intel Corp.
9 * All rights reserved.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
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.
30 * NO WARRANTY
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>
47 #include "accommon.h"
48 #include "actables.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
60 * RETURN: Status
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.
88 * RETURN: Status
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 __init
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;
106 acpi_status status;
108 ACPI_FUNCTION_TRACE(acpi_initialize_tables);
111 * Setup the Root Table Array and allocate the table array
112 * if requested
114 if (!initial_table_array) {
115 status = acpi_allocate_root_table(initial_table_count);
116 if (ACPI_FAILURE(status)) {
117 return_ACPI_STATUS(status);
119 } else {
120 /* Root Table Array has been statically allocated by the host */
122 ACPI_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;
129 if (allow_resize) {
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();
138 if (!rsdp_address) {
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
157 * PARAMETERS: None
159 * RETURN: Status
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
164 * kernel.
166 ******************************************************************************/
167 acpi_status __init acpi_reallocate_root_table(void)
169 acpi_status status;
171 ACPI_FUNCTION_TRACE(acpi_reallocate_root_table);
174 * Only reallocate the root table if the host provided a static buffer
175 * for the table array in the call to acpi_initialize_tables.
177 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
178 return_ACPI_STATUS(AE_SUPPORT);
181 acpi_gbl_root_table_list.flags |= ACPI_ROOT_ALLOW_RESIZE;
183 status = acpi_tb_resize_root_table_list();
184 return_ACPI_STATUS(status);
187 ACPI_EXPORT_SYMBOL_INIT(acpi_reallocate_root_table)
189 /*******************************************************************************
191 * FUNCTION: acpi_get_table_header
193 * PARAMETERS: signature - ACPI signature of needed table
194 * instance - Which instance (for SSDTs)
195 * out_table_header - The pointer to the table header to fill
197 * RETURN: Status and pointer to mapped table header
199 * DESCRIPTION: Finds an ACPI table header.
201 * NOTE: Caller is responsible in unmapping the header with
202 * acpi_os_unmap_memory
204 ******************************************************************************/
205 acpi_status
206 acpi_get_table_header(char *signature,
207 u32 instance, struct acpi_table_header *out_table_header)
209 u32 i;
210 u32 j;
211 struct acpi_table_header *header;
213 /* Parameter validation */
215 if (!signature || !out_table_header) {
216 return (AE_BAD_PARAMETER);
219 /* Walk the root table list */
221 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count;
222 i++) {
223 if (!ACPI_COMPARE_NAME
224 (&(acpi_gbl_root_table_list.tables[i].signature),
225 signature)) {
226 continue;
229 if (++j < instance) {
230 continue;
233 if (!acpi_gbl_root_table_list.tables[i].pointer) {
234 if ((acpi_gbl_root_table_list.tables[i].flags &
235 ACPI_TABLE_ORIGIN_MASK) ==
236 ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL) {
237 header =
238 acpi_os_map_memory(acpi_gbl_root_table_list.
239 tables[i].address,
240 sizeof(struct
241 acpi_table_header));
242 if (!header) {
243 return (AE_NO_MEMORY);
245 ACPI_MEMCPY(out_table_header, header,
246 sizeof(struct acpi_table_header));
247 acpi_os_unmap_memory(header,
248 sizeof(struct
249 acpi_table_header));
250 } else {
251 return (AE_NOT_FOUND);
253 } else {
254 ACPI_MEMCPY(out_table_header,
255 acpi_gbl_root_table_list.tables[i].pointer,
256 sizeof(struct acpi_table_header));
258 return (AE_OK);
261 return (AE_NOT_FOUND);
264 ACPI_EXPORT_SYMBOL(acpi_get_table_header)
266 /*******************************************************************************
268 * FUNCTION: acpi_get_table_with_size
270 * PARAMETERS: signature - ACPI signature of needed table
271 * instance - Which instance (for SSDTs)
272 * out_table - Where the pointer to the table is returned
274 * RETURN: Status and pointer to the requested table
276 * DESCRIPTION: Finds and verifies an ACPI table. Table must be in the
277 * RSDT/XSDT.
279 ******************************************************************************/
280 acpi_status
281 acpi_get_table_with_size(char *signature,
282 u32 instance, struct acpi_table_header **out_table,
283 acpi_size *tbl_size)
285 u32 i;
286 u32 j;
287 acpi_status status;
289 /* Parameter validation */
291 if (!signature || !out_table) {
292 return (AE_BAD_PARAMETER);
295 /* Walk the root table list */
297 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count;
298 i++) {
299 if (!ACPI_COMPARE_NAME
300 (&(acpi_gbl_root_table_list.tables[i].signature),
301 signature)) {
302 continue;
305 if (++j < instance) {
306 continue;
309 status =
310 acpi_tb_validate_table(&acpi_gbl_root_table_list.tables[i]);
311 if (ACPI_SUCCESS(status)) {
312 *out_table = acpi_gbl_root_table_list.tables[i].pointer;
313 *tbl_size = acpi_gbl_root_table_list.tables[i].length;
316 if (!acpi_gbl_permanent_mmap) {
317 acpi_gbl_root_table_list.tables[i].pointer = NULL;
320 return (status);
323 return (AE_NOT_FOUND);
326 ACPI_EXPORT_SYMBOL(acpi_get_table_with_size)
328 acpi_status
329 acpi_get_table(char *signature,
330 u32 instance, struct acpi_table_header **out_table)
332 acpi_size tbl_size;
334 return acpi_get_table_with_size(signature,
335 instance, out_table, &tbl_size);
338 ACPI_EXPORT_SYMBOL(acpi_get_table)
340 /*******************************************************************************
342 * FUNCTION: acpi_get_table_by_index
344 * PARAMETERS: table_index - Table index
345 * table - Where the pointer to the table is returned
347 * RETURN: Status and pointer to the requested table
349 * DESCRIPTION: Obtain a table by an index into the global table list. Used
350 * internally also.
352 ******************************************************************************/
353 acpi_status
354 acpi_get_table_by_index(u32 table_index, struct acpi_table_header ** table)
356 acpi_status status;
358 ACPI_FUNCTION_TRACE(acpi_get_table_by_index);
360 /* Parameter validation */
362 if (!table) {
363 return_ACPI_STATUS(AE_BAD_PARAMETER);
366 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
368 /* Validate index */
370 if (table_index >= acpi_gbl_root_table_list.current_table_count) {
371 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
372 return_ACPI_STATUS(AE_BAD_PARAMETER);
375 if (!acpi_gbl_root_table_list.tables[table_index].pointer) {
377 /* Table is not mapped, map it */
379 status =
380 acpi_tb_validate_table(&acpi_gbl_root_table_list.
381 tables[table_index]);
382 if (ACPI_FAILURE(status)) {
383 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
384 return_ACPI_STATUS(status);
388 *table = acpi_gbl_root_table_list.tables[table_index].pointer;
389 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
390 return_ACPI_STATUS(AE_OK);
393 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index)
395 /*******************************************************************************
397 * FUNCTION: acpi_install_table_handler
399 * PARAMETERS: handler - Table event handler
400 * context - Value passed to the handler on each event
402 * RETURN: Status
404 * DESCRIPTION: Install a global table event handler.
406 ******************************************************************************/
407 acpi_status
408 acpi_install_table_handler(acpi_table_handler handler, void *context)
410 acpi_status status;
412 ACPI_FUNCTION_TRACE(acpi_install_table_handler);
414 if (!handler) {
415 return_ACPI_STATUS(AE_BAD_PARAMETER);
418 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
419 if (ACPI_FAILURE(status)) {
420 return_ACPI_STATUS(status);
423 /* Don't allow more than one handler */
425 if (acpi_gbl_table_handler) {
426 status = AE_ALREADY_EXISTS;
427 goto cleanup;
430 /* Install the handler */
432 acpi_gbl_table_handler = handler;
433 acpi_gbl_table_handler_context = context;
435 cleanup:
436 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
437 return_ACPI_STATUS(status);
440 ACPI_EXPORT_SYMBOL(acpi_install_table_handler)
442 /*******************************************************************************
444 * FUNCTION: acpi_remove_table_handler
446 * PARAMETERS: handler - Table event handler that was installed
447 * previously.
449 * RETURN: Status
451 * DESCRIPTION: Remove a table event handler
453 ******************************************************************************/
454 acpi_status acpi_remove_table_handler(acpi_table_handler handler)
456 acpi_status status;
458 ACPI_FUNCTION_TRACE(acpi_remove_table_handler);
460 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
461 if (ACPI_FAILURE(status)) {
462 return_ACPI_STATUS(status);
465 /* Make sure that the installed handler is the same */
467 if (!handler || handler != acpi_gbl_table_handler) {
468 status = AE_BAD_PARAMETER;
469 goto cleanup;
472 /* Remove the handler */
474 acpi_gbl_table_handler = NULL;
476 cleanup:
477 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
478 return_ACPI_STATUS(status);
481 ACPI_EXPORT_SYMBOL(acpi_remove_table_handler)