1 /******************************************************************************
2 *
3 * Module Name: tbxface - ACPI table-oriented external interfaces
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2017, Intel Corp.
9 * All rights reserved.
10 *
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.
25 *
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.
29 *
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.
42 */
43
44 #define EXPORT_ACPI_INTERFACES
45
46 #include <acpi/acpi.h>
47 #include "accommon.h"
48 #include "actables.h"
49
50 #define _COMPONENT ACPI_TABLES
51 ACPI_MODULE_NAME("tbxface")
52
53 /*******************************************************************************
54 *
55 * FUNCTION: acpi_allocate_root_table
56 *
57 * PARAMETERS: initial_table_count - Size of initial_table_array, in number of
58 * struct acpi_table_desc structures
59 *
60 * RETURN: Status
61 *
62 * DESCRIPTION: Allocate a root table array. Used by iASL compiler and
63 * acpi_initialize_tables.
64 *
65 ******************************************************************************/
acpi_allocate_root_table(u32 initial_table_count)66 acpi_status acpi_allocate_root_table(u32 initial_table_count)
67 {
68
69 acpi_gbl_root_table_list.max_table_count = initial_table_count;
70 acpi_gbl_root_table_list.flags = ACPI_ROOT_ALLOW_RESIZE;
71
72 return (acpi_tb_resize_root_table_list());
73 }
74
75 /*******************************************************************************
76 *
77 * FUNCTION: acpi_initialize_tables
78 *
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.
87 *
88 * RETURN: Status
89 *
90 * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT.
91 *
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.
95 *
96 * If the host OS memory managers are initialized, use NULL for
97 * initial_table_array, and the table will be dynamically allocated.
98 *
99 ******************************************************************************/
100
101 acpi_status ACPI_INIT_FUNCTION
acpi_initialize_tables(struct acpi_table_desc * initial_table_array,u32 initial_table_count,u8 allow_resize)102 acpi_initialize_tables(struct acpi_table_desc *initial_table_array,
103 u32 initial_table_count, u8 allow_resize)
104 {
105 acpi_physical_address rsdp_address;
106 acpi_status status;
107
108 ACPI_FUNCTION_TRACE(acpi_initialize_tables);
109
110 /*
111 * Setup the Root Table Array and allocate the table array
112 * if requested
113 */
114 if (!initial_table_array) {
115 status = acpi_allocate_root_table(initial_table_count);
116 if (ACPI_FAILURE(status)) {
117 return_ACPI_STATUS(status);
118 }
119 } else {
120 /* Root Table Array has been statically allocated by the host */
121
122 memset(initial_table_array, 0,
123 (acpi_size)initial_table_count *
124 sizeof(struct acpi_table_desc));
125
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;
132 }
133 }
134
135 /* Get the address of the RSDP */
136
137 rsdp_address = acpi_os_get_root_pointer();
138 if (!rsdp_address) {
139 return_ACPI_STATUS(AE_NOT_FOUND);
140 }
141
142 /*
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.
146 */
147 status = acpi_tb_parse_root_table(rsdp_address);
148 return_ACPI_STATUS(status);
149 }
150
ACPI_EXPORT_SYMBOL_INIT(acpi_initialize_tables)151 ACPI_EXPORT_SYMBOL_INIT(acpi_initialize_tables)
152
153 /*******************************************************************************
154 *
155 * FUNCTION: acpi_reallocate_root_table
156 *
157 * PARAMETERS: None
158 *
159 * RETURN: Status
160 *
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.
165 *
166 ******************************************************************************/
167 acpi_status ACPI_INIT_FUNCTION acpi_reallocate_root_table(void)
168 {
169 acpi_status status;
170 struct acpi_table_desc *table_desc;
171 u32 i, j;
172
173 ACPI_FUNCTION_TRACE(acpi_reallocate_root_table);
174
175 /*
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.
178 */
179 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
180 return_ACPI_STATUS(AE_SUPPORT);
181 }
182
183 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
184
185 /*
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
189 * early stage.
190 */
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) {
194 ACPI_ERROR((AE_INFO,
195 "Table [%4.4s] is not invalidated during early boot stage",
196 table_desc->signature.ascii));
197 }
198 }
199
200 if (!acpi_gbl_enable_table_validation) {
201 /*
202 * Now it's safe to do full table validation. We can do deferred
203 * table initilization here once the flag is set.
204 */
205 acpi_gbl_enable_table_validation = TRUE;
206 for (i = 0; i < acpi_gbl_root_table_list.current_table_count;
207 ++i) {
208 table_desc = &acpi_gbl_root_table_list.tables[i];
209 if (!(table_desc->flags & ACPI_TABLE_IS_VERIFIED)) {
210 status =
211 acpi_tb_verify_temp_table(table_desc, NULL,
212 &j);
213 if (ACPI_FAILURE(status)) {
214 acpi_tb_uninstall_table(table_desc);
215 }
216 }
217 }
218 }
219
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;
223
224 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
225 return_ACPI_STATUS(status);
226 }
227
ACPI_EXPORT_SYMBOL_INIT(acpi_reallocate_root_table)228 ACPI_EXPORT_SYMBOL_INIT(acpi_reallocate_root_table)
229
230 /*******************************************************************************
231 *
232 * FUNCTION: acpi_get_table_header
233 *
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
237 *
238 * RETURN: Status and pointer to mapped table header
239 *
240 * DESCRIPTION: Finds an ACPI table header.
241 *
242 * NOTE: Caller is responsible in unmapping the header with
243 * acpi_os_unmap_memory
244 *
245 ******************************************************************************/
246 acpi_status
247 acpi_get_table_header(char *signature,
248 u32 instance, struct acpi_table_header *out_table_header)
249 {
250 u32 i;
251 u32 j;
252 struct acpi_table_header *header;
253
254 /* Parameter validation */
255
256 if (!signature || !out_table_header) {
257 return (AE_BAD_PARAMETER);
258 }
259
260 /* Walk the root table list */
261
262 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count;
263 i++) {
264 if (!ACPI_COMPARE_NAME
265 (&(acpi_gbl_root_table_list.tables[i].signature),
266 signature)) {
267 continue;
268 }
269
270 if (++j < instance) {
271 continue;
272 }
273
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) {
278 header =
279 acpi_os_map_memory(acpi_gbl_root_table_list.
280 tables[i].address,
281 sizeof(struct
282 acpi_table_header));
283 if (!header) {
284 return (AE_NO_MEMORY);
285 }
286
287 memcpy(out_table_header, header,
288 sizeof(struct acpi_table_header));
289 acpi_os_unmap_memory(header,
290 sizeof(struct
291 acpi_table_header));
292 } else {
293 return (AE_NOT_FOUND);
294 }
295 } else {
296 memcpy(out_table_header,
297 acpi_gbl_root_table_list.tables[i].pointer,
298 sizeof(struct acpi_table_header));
299 }
300 return (AE_OK);
301 }
302
303 return (AE_NOT_FOUND);
304 }
305
ACPI_EXPORT_SYMBOL(acpi_get_table_header)306 ACPI_EXPORT_SYMBOL(acpi_get_table_header)
307
308 /*******************************************************************************
309 *
310 * FUNCTION: acpi_get_table
311 *
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
315 *
316 * RETURN: Status and pointer to the requested table
317 *
318 * DESCRIPTION: Finds and verifies an ACPI table. Table must be in the
319 * RSDT/XSDT.
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.
325 *
326 ******************************************************************************/
327 acpi_status
328 acpi_get_table(char *signature,
329 u32 instance, struct acpi_table_header ** out_table)
330 {
331 u32 i;
332 u32 j;
333 acpi_status status = AE_NOT_FOUND;
334 struct acpi_table_desc *table_desc;
335
336 /* Parameter validation */
337
338 if (!signature || !out_table) {
339 return (AE_BAD_PARAMETER);
340 }
341
342 /*
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.
346 */
347 *out_table = NULL;
348
349 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
350
351 /* Walk the root table list */
352
353 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count;
354 i++) {
355 table_desc = &acpi_gbl_root_table_list.tables[i];
356
357 if (!ACPI_COMPARE_NAME(&table_desc->signature, signature)) {
358 continue;
359 }
360
361 if (++j < instance) {
362 continue;
363 }
364
365 status = acpi_tb_get_table(table_desc, out_table);
366 break;
367 }
368
369 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
370 return (status);
371 }
372
ACPI_EXPORT_SYMBOL(acpi_get_table)373 ACPI_EXPORT_SYMBOL(acpi_get_table)
374
375 /*******************************************************************************
376 *
377 * FUNCTION: acpi_put_table
378 *
379 * PARAMETERS: table - The pointer to the table
380 *
381 * RETURN: None
382 *
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
387 * situations.
388 *
389 ******************************************************************************/
390 void acpi_put_table(struct acpi_table_header *table)
391 {
392 u32 i;
393 struct acpi_table_desc *table_desc;
394
395 ACPI_FUNCTION_TRACE(acpi_put_table);
396
397 if (!table) {
398 return_VOID;
399 }
400
401 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
402
403 /* Walk the root table list */
404
405 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) {
406 table_desc = &acpi_gbl_root_table_list.tables[i];
407
408 if (table_desc->pointer != table) {
409 continue;
410 }
411
412 acpi_tb_put_table(table_desc);
413 break;
414 }
415
416 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
417 return_VOID;
418 }
419
ACPI_EXPORT_SYMBOL(acpi_put_table)420 ACPI_EXPORT_SYMBOL(acpi_put_table)
421
422 /*******************************************************************************
423 *
424 * FUNCTION: acpi_get_table_by_index
425 *
426 * PARAMETERS: table_index - Table index
427 * out_table - Where the pointer to the table is returned
428 *
429 * RETURN: Status and pointer to the requested table
430 *
431 * DESCRIPTION: Obtain a table by an index into the global table list. Used
432 * internally also.
433 *
434 ******************************************************************************/
435 acpi_status
436 acpi_get_table_by_index(u32 table_index, struct acpi_table_header **out_table)
437 {
438 acpi_status status;
439
440 ACPI_FUNCTION_TRACE(acpi_get_table_by_index);
441
442 /* Parameter validation */
443
444 if (!out_table) {
445 return_ACPI_STATUS(AE_BAD_PARAMETER);
446 }
447
448 /*
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.
452 */
453 *out_table = NULL;
454
455 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
456
457 /* Validate index */
458
459 if (table_index >= acpi_gbl_root_table_list.current_table_count) {
460 status = AE_BAD_PARAMETER;
461 goto unlock_and_exit;
462 }
463
464 status =
465 acpi_tb_get_table(&acpi_gbl_root_table_list.tables[table_index],
466 out_table);
467
468 unlock_and_exit:
469 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
470 return_ACPI_STATUS(status);
471 }
472
ACPI_EXPORT_SYMBOL(acpi_get_table_by_index)473 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index)
474
475 /*******************************************************************************
476 *
477 * FUNCTION: acpi_install_table_handler
478 *
479 * PARAMETERS: handler - Table event handler
480 * context - Value passed to the handler on each event
481 *
482 * RETURN: Status
483 *
484 * DESCRIPTION: Install a global table event handler.
485 *
486 ******************************************************************************/
487 acpi_status
488 acpi_install_table_handler(acpi_table_handler handler, void *context)
489 {
490 acpi_status status;
491
492 ACPI_FUNCTION_TRACE(acpi_install_table_handler);
493
494 if (!handler) {
495 return_ACPI_STATUS(AE_BAD_PARAMETER);
496 }
497
498 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
499 if (ACPI_FAILURE(status)) {
500 return_ACPI_STATUS(status);
501 }
502
503 /* Don't allow more than one handler */
504
505 if (acpi_gbl_table_handler) {
506 status = AE_ALREADY_EXISTS;
507 goto cleanup;
508 }
509
510 /* Install the handler */
511
512 acpi_gbl_table_handler = handler;
513 acpi_gbl_table_handler_context = context;
514
515 cleanup:
516 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
517 return_ACPI_STATUS(status);
518 }
519
ACPI_EXPORT_SYMBOL(acpi_install_table_handler)520 ACPI_EXPORT_SYMBOL(acpi_install_table_handler)
521
522 /*******************************************************************************
523 *
524 * FUNCTION: acpi_remove_table_handler
525 *
526 * PARAMETERS: handler - Table event handler that was installed
527 * previously.
528 *
529 * RETURN: Status
530 *
531 * DESCRIPTION: Remove a table event handler
532 *
533 ******************************************************************************/
534 acpi_status acpi_remove_table_handler(acpi_table_handler handler)
535 {
536 acpi_status status;
537
538 ACPI_FUNCTION_TRACE(acpi_remove_table_handler);
539
540 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
541 if (ACPI_FAILURE(status)) {
542 return_ACPI_STATUS(status);
543 }
544
545 /* Make sure that the installed handler is the same */
546
547 if (!handler || handler != acpi_gbl_table_handler) {
548 status = AE_BAD_PARAMETER;
549 goto cleanup;
550 }
551
552 /* Remove the handler */
553
554 acpi_gbl_table_handler = NULL;
555
556 cleanup:
557 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
558 return_ACPI_STATUS(status);
559 }
560
561 ACPI_EXPORT_SYMBOL(acpi_remove_table_handler)
562