Merge tag 'trace-v5.11-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt...
[linux/fpc-iii.git] / drivers / acpi / acpica / tbxface.c
blob7490429ddbf628fdf03a8a615cdea45e46f5afbc
1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
4 * Module Name: tbxface - ACPI table-oriented external interfaces
6 * Copyright (C) 2000 - 2020, Intel Corp.
8 *****************************************************************************/
10 #define EXPORT_ACPI_INTERFACES
12 #include <acpi/acpi.h>
13 #include "accommon.h"
14 #include "actables.h"
16 #define _COMPONENT ACPI_TABLES
17 ACPI_MODULE_NAME("tbxface")
19 /*******************************************************************************
21 * FUNCTION: acpi_allocate_root_table
23 * PARAMETERS: initial_table_count - Size of initial_table_array, in number of
24 * struct acpi_table_desc structures
26 * RETURN: Status
28 * DESCRIPTION: Allocate a root table array. Used by iASL compiler and
29 * acpi_initialize_tables.
31 ******************************************************************************/
32 acpi_status acpi_allocate_root_table(u32 initial_table_count)
35 acpi_gbl_root_table_list.max_table_count = initial_table_count;
36 acpi_gbl_root_table_list.flags = ACPI_ROOT_ALLOW_RESIZE;
38 return (acpi_tb_resize_root_table_list());
41 /*******************************************************************************
43 * FUNCTION: acpi_initialize_tables
45 * PARAMETERS: initial_table_array - Pointer to an array of pre-allocated
46 * struct acpi_table_desc structures. If NULL, the
47 * array is dynamically allocated.
48 * initial_table_count - Size of initial_table_array, in number of
49 * struct acpi_table_desc structures
50 * allow_resize - Flag to tell Table Manager if resize of
51 * pre-allocated array is allowed. Ignored
52 * if initial_table_array is NULL.
54 * RETURN: Status
56 * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT.
58 * NOTE: Allows static allocation of the initial table array in order
59 * to avoid the use of dynamic memory in confined environments
60 * such as the kernel boot sequence where it may not be available.
62 * If the host OS memory managers are initialized, use NULL for
63 * initial_table_array, and the table will be dynamically allocated.
65 ******************************************************************************/
67 acpi_status ACPI_INIT_FUNCTION
68 acpi_initialize_tables(struct acpi_table_desc *initial_table_array,
69 u32 initial_table_count, u8 allow_resize)
71 acpi_physical_address rsdp_address;
72 acpi_status status;
74 ACPI_FUNCTION_TRACE(acpi_initialize_tables);
77 * Setup the Root Table Array and allocate the table array
78 * if requested
80 if (!initial_table_array) {
81 status = acpi_allocate_root_table(initial_table_count);
82 if (ACPI_FAILURE(status)) {
83 return_ACPI_STATUS(status);
85 } else {
86 /* Root Table Array has been statically allocated by the host */
88 memset(initial_table_array, 0,
89 (acpi_size)initial_table_count *
90 sizeof(struct acpi_table_desc));
92 acpi_gbl_root_table_list.tables = initial_table_array;
93 acpi_gbl_root_table_list.max_table_count = initial_table_count;
94 acpi_gbl_root_table_list.flags = ACPI_ROOT_ORIGIN_UNKNOWN;
95 if (allow_resize) {
96 acpi_gbl_root_table_list.flags |=
97 ACPI_ROOT_ALLOW_RESIZE;
101 /* Get the address of the RSDP */
103 rsdp_address = acpi_os_get_root_pointer();
104 if (!rsdp_address) {
105 return_ACPI_STATUS(AE_NOT_FOUND);
109 * Get the root table (RSDT or XSDT) and extract all entries to the local
110 * Root Table Array. This array contains the information of the RSDT/XSDT
111 * in a common, more usable format.
113 status = acpi_tb_parse_root_table(rsdp_address);
114 return_ACPI_STATUS(status);
117 ACPI_EXPORT_SYMBOL_INIT(acpi_initialize_tables)
119 /*******************************************************************************
121 * FUNCTION: acpi_reallocate_root_table
123 * PARAMETERS: None
125 * RETURN: Status
127 * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the
128 * root list from the previously provided scratch area. Should
129 * be called once dynamic memory allocation is available in the
130 * kernel.
132 ******************************************************************************/
133 acpi_status ACPI_INIT_FUNCTION acpi_reallocate_root_table(void)
135 acpi_status status;
136 struct acpi_table_desc *table_desc;
137 u32 i, j;
139 ACPI_FUNCTION_TRACE(acpi_reallocate_root_table);
142 * If there are tables unverified, it is required to reallocate the
143 * root table list to clean up invalid table entries. Otherwise only
144 * reallocate the root table list if the host provided a static buffer
145 * for the table array in the call to acpi_initialize_tables().
147 if ((acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) &&
148 acpi_gbl_enable_table_validation) {
149 return_ACPI_STATUS(AE_SUPPORT);
152 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
155 * Ensure OS early boot logic, which is required by some hosts. If the
156 * table state is reported to be wrong, developers should fix the
157 * issue by invoking acpi_put_table() for the reported table during the
158 * early stage.
160 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) {
161 table_desc = &acpi_gbl_root_table_list.tables[i];
162 if (table_desc->pointer) {
163 ACPI_ERROR((AE_INFO,
164 "Table [%4.4s] is not invalidated during early boot stage",
165 table_desc->signature.ascii));
169 if (!acpi_gbl_enable_table_validation) {
171 * Now it's safe to do full table validation. We can do deferred
172 * table initialization here once the flag is set.
174 acpi_gbl_enable_table_validation = TRUE;
175 for (i = 0; i < acpi_gbl_root_table_list.current_table_count;
176 ++i) {
177 table_desc = &acpi_gbl_root_table_list.tables[i];
178 if (!(table_desc->flags & ACPI_TABLE_IS_VERIFIED)) {
179 status =
180 acpi_tb_verify_temp_table(table_desc, NULL,
181 &j);
182 if (ACPI_FAILURE(status)) {
183 acpi_tb_uninstall_table(table_desc);
189 acpi_gbl_root_table_list.flags |= ACPI_ROOT_ALLOW_RESIZE;
190 status = acpi_tb_resize_root_table_list();
191 acpi_gbl_root_table_list.flags |= ACPI_ROOT_ORIGIN_ALLOCATED;
193 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
194 return_ACPI_STATUS(status);
197 ACPI_EXPORT_SYMBOL_INIT(acpi_reallocate_root_table)
199 /*******************************************************************************
201 * FUNCTION: acpi_get_table_header
203 * PARAMETERS: signature - ACPI signature of needed table
204 * instance - Which instance (for SSDTs)
205 * out_table_header - The pointer to the where the table header
206 * is returned
208 * RETURN: Status and a copy of the table header
210 * DESCRIPTION: Finds and returns an ACPI table header. Caller provides the
211 * memory where a copy of the header is to be returned
212 * (fixed length).
214 ******************************************************************************/
215 acpi_status
216 acpi_get_table_header(char *signature,
217 u32 instance, struct acpi_table_header *out_table_header)
219 u32 i;
220 u32 j;
221 struct acpi_table_header *header;
223 /* Parameter validation */
225 if (!signature || !out_table_header) {
226 return (AE_BAD_PARAMETER);
229 /* Walk the root table list */
231 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count;
232 i++) {
233 if (!ACPI_COMPARE_NAMESEG
234 (&(acpi_gbl_root_table_list.tables[i].signature),
235 signature)) {
236 continue;
239 if (++j < instance) {
240 continue;
243 if (!acpi_gbl_root_table_list.tables[i].pointer) {
244 if ((acpi_gbl_root_table_list.tables[i].flags &
245 ACPI_TABLE_ORIGIN_MASK) ==
246 ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL) {
247 header =
248 acpi_os_map_memory(acpi_gbl_root_table_list.
249 tables[i].address,
250 sizeof(struct
251 acpi_table_header));
252 if (!header) {
253 return (AE_NO_MEMORY);
256 memcpy(out_table_header, header,
257 sizeof(struct acpi_table_header));
258 acpi_os_unmap_memory(header,
259 sizeof(struct
260 acpi_table_header));
261 } else {
262 return (AE_NOT_FOUND);
264 } else {
265 memcpy(out_table_header,
266 acpi_gbl_root_table_list.tables[i].pointer,
267 sizeof(struct acpi_table_header));
269 return (AE_OK);
272 return (AE_NOT_FOUND);
275 ACPI_EXPORT_SYMBOL(acpi_get_table_header)
277 /*******************************************************************************
279 * FUNCTION: acpi_get_table
281 * PARAMETERS: signature - ACPI signature of needed table
282 * instance - Which instance (for SSDTs)
283 * out_table - Where the pointer to the table is returned
285 * RETURN: Status and pointer to the requested table
287 * DESCRIPTION: Finds and verifies an ACPI table. Table must be in the
288 * RSDT/XSDT.
289 * Note that an early stage acpi_get_table() call must be paired
290 * with an early stage acpi_put_table() call. otherwise the table
291 * pointer mapped by the early stage mapping implementation may be
292 * erroneously unmapped by the late stage unmapping implementation
293 * in an acpi_put_table() invoked during the late stage.
295 ******************************************************************************/
296 acpi_status
297 acpi_get_table(char *signature,
298 u32 instance, struct acpi_table_header ** out_table)
300 u32 i;
301 u32 j;
302 acpi_status status = AE_NOT_FOUND;
303 struct acpi_table_desc *table_desc;
305 /* Parameter validation */
307 if (!signature || !out_table) {
308 return (AE_BAD_PARAMETER);
312 * Note that the following line is required by some OSPMs, they only
313 * check if the returned table is NULL instead of the returned status
314 * to determined if this function is succeeded.
316 *out_table = NULL;
318 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
320 /* Walk the root table list */
322 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count;
323 i++) {
324 table_desc = &acpi_gbl_root_table_list.tables[i];
326 if (!ACPI_COMPARE_NAMESEG(&table_desc->signature, signature)) {
327 continue;
330 if (++j < instance) {
331 continue;
334 status = acpi_tb_get_table(table_desc, out_table);
335 break;
338 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
339 return (status);
342 ACPI_EXPORT_SYMBOL(acpi_get_table)
344 /*******************************************************************************
346 * FUNCTION: acpi_put_table
348 * PARAMETERS: table - The pointer to the table
350 * RETURN: None
352 * DESCRIPTION: Release a table returned by acpi_get_table() and its clones.
353 * Note that it is not safe if this function was invoked after an
354 * uninstallation happened to the original table descriptor.
355 * Currently there is no OSPMs' requirement to handle such
356 * situations.
358 ******************************************************************************/
359 void acpi_put_table(struct acpi_table_header *table)
361 u32 i;
362 struct acpi_table_desc *table_desc;
364 ACPI_FUNCTION_TRACE(acpi_put_table);
366 if (!table) {
367 return_VOID;
370 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
372 /* Walk the root table list */
374 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) {
375 table_desc = &acpi_gbl_root_table_list.tables[i];
377 if (table_desc->pointer != table) {
378 continue;
381 acpi_tb_put_table(table_desc);
382 break;
385 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
386 return_VOID;
389 ACPI_EXPORT_SYMBOL(acpi_put_table)
391 /*******************************************************************************
393 * FUNCTION: acpi_get_table_by_index
395 * PARAMETERS: table_index - Table index
396 * out_table - Where the pointer to the table is returned
398 * RETURN: Status and pointer to the requested table
400 * DESCRIPTION: Obtain a table by an index into the global table list. Used
401 * internally also.
403 ******************************************************************************/
404 acpi_status
405 acpi_get_table_by_index(u32 table_index, struct acpi_table_header **out_table)
407 acpi_status status;
409 ACPI_FUNCTION_TRACE(acpi_get_table_by_index);
411 /* Parameter validation */
413 if (!out_table) {
414 return_ACPI_STATUS(AE_BAD_PARAMETER);
418 * Note that the following line is required by some OSPMs, they only
419 * check if the returned table is NULL instead of the returned status
420 * to determined if this function is succeeded.
422 *out_table = NULL;
424 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
426 /* Validate index */
428 if (table_index >= acpi_gbl_root_table_list.current_table_count) {
429 status = AE_BAD_PARAMETER;
430 goto unlock_and_exit;
433 status =
434 acpi_tb_get_table(&acpi_gbl_root_table_list.tables[table_index],
435 out_table);
437 unlock_and_exit:
438 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
439 return_ACPI_STATUS(status);
442 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index)
444 /*******************************************************************************
446 * FUNCTION: acpi_install_table_handler
448 * PARAMETERS: handler - Table event handler
449 * context - Value passed to the handler on each event
451 * RETURN: Status
453 * DESCRIPTION: Install a global table event handler.
455 ******************************************************************************/
456 acpi_status
457 acpi_install_table_handler(acpi_table_handler handler, void *context)
459 acpi_status status;
461 ACPI_FUNCTION_TRACE(acpi_install_table_handler);
463 if (!handler) {
464 return_ACPI_STATUS(AE_BAD_PARAMETER);
467 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
468 if (ACPI_FAILURE(status)) {
469 return_ACPI_STATUS(status);
472 /* Don't allow more than one handler */
474 if (acpi_gbl_table_handler) {
475 status = AE_ALREADY_EXISTS;
476 goto cleanup;
479 /* Install the handler */
481 acpi_gbl_table_handler = handler;
482 acpi_gbl_table_handler_context = context;
484 cleanup:
485 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
486 return_ACPI_STATUS(status);
489 ACPI_EXPORT_SYMBOL(acpi_install_table_handler)
491 /*******************************************************************************
493 * FUNCTION: acpi_remove_table_handler
495 * PARAMETERS: handler - Table event handler that was installed
496 * previously.
498 * RETURN: Status
500 * DESCRIPTION: Remove a table event handler
502 ******************************************************************************/
503 acpi_status acpi_remove_table_handler(acpi_table_handler handler)
505 acpi_status status;
507 ACPI_FUNCTION_TRACE(acpi_remove_table_handler);
509 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
510 if (ACPI_FAILURE(status)) {
511 return_ACPI_STATUS(status);
514 /* Make sure that the installed handler is the same */
516 if (!handler || handler != acpi_gbl_table_handler) {
517 status = AE_BAD_PARAMETER;
518 goto cleanup;
521 /* Remove the handler */
523 acpi_gbl_table_handler = NULL;
525 cleanup:
526 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
527 return_ACPI_STATUS(status);
530 ACPI_EXPORT_SYMBOL(acpi_remove_table_handler)