1 /******************************************************************************
2 *
3 * Module Name: tbdata - Table manager data structure functions
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 #include <acpi/acpi.h>
45 #include "accommon.h"
46 #include "acnamesp.h"
47 #include "actables.h"
48 #include "acevents.h"
49
50 #define _COMPONENT ACPI_TABLES
51 ACPI_MODULE_NAME("tbdata")
52
53 /* Local prototypes */
54 static acpi_status
55 acpi_tb_check_duplication(struct acpi_table_desc *table_desc, u32 *table_index);
56
57 static u8
58 acpi_tb_compare_tables(struct acpi_table_desc *table_desc, u32 table_index);
59
60 /*******************************************************************************
61 *
62 * FUNCTION: acpi_tb_compare_tables
63 *
64 * PARAMETERS: table_desc - Table 1 descriptor to be compared
65 * table_index - Index of table 2 to be compared
66 *
67 * RETURN: TRUE if both tables are identical.
68 *
69 * DESCRIPTION: This function compares a table with another table that has
70 * already been installed in the root table list.
71 *
72 ******************************************************************************/
73
74 static u8
acpi_tb_compare_tables(struct acpi_table_desc * table_desc,u32 table_index)75 acpi_tb_compare_tables(struct acpi_table_desc *table_desc, u32 table_index)
76 {
77 acpi_status status = AE_OK;
78 u8 is_identical;
79 struct acpi_table_header *table;
80 u32 table_length;
81 u8 table_flags;
82
83 status =
84 acpi_tb_acquire_table(&acpi_gbl_root_table_list.tables[table_index],
85 &table, &table_length, &table_flags);
86 if (ACPI_FAILURE(status)) {
87 return (FALSE);
88 }
89
90 /*
91 * Check for a table match on the entire table length,
92 * not just the header.
93 */
94 is_identical = (u8)((table_desc->length != table_length ||
95 memcmp(table_desc->pointer, table, table_length)) ?
96 FALSE : TRUE);
97
98 /* Release the acquired table */
99
100 acpi_tb_release_table(table, table_length, table_flags);
101 return (is_identical);
102 }
103
104 /*******************************************************************************
105 *
106 * FUNCTION: acpi_tb_init_table_descriptor
107 *
108 * PARAMETERS: table_desc - Table descriptor
109 * address - Physical address of the table
110 * flags - Allocation flags of the table
111 * table - Pointer to the table
112 *
113 * RETURN: None
114 *
115 * DESCRIPTION: Initialize a new table descriptor
116 *
117 ******************************************************************************/
118
119 void
acpi_tb_init_table_descriptor(struct acpi_table_desc * table_desc,acpi_physical_address address,u8 flags,struct acpi_table_header * table)120 acpi_tb_init_table_descriptor(struct acpi_table_desc *table_desc,
121 acpi_physical_address address,
122 u8 flags, struct acpi_table_header *table)
123 {
124
125 /*
126 * Initialize the table descriptor. Set the pointer to NULL, since the
127 * table is not fully mapped at this time.
128 */
129 memset(table_desc, 0, sizeof(struct acpi_table_desc));
130 table_desc->address = address;
131 table_desc->length = table->length;
132 table_desc->flags = flags;
133 ACPI_MOVE_32_TO_32(table_desc->signature.ascii, table->signature);
134 }
135
136 /*******************************************************************************
137 *
138 * FUNCTION: acpi_tb_acquire_table
139 *
140 * PARAMETERS: table_desc - Table descriptor
141 * table_ptr - Where table is returned
142 * table_length - Where table length is returned
143 * table_flags - Where table allocation flags are returned
144 *
145 * RETURN: Status
146 *
147 * DESCRIPTION: Acquire an ACPI table. It can be used for tables not
148 * maintained in the acpi_gbl_root_table_list.
149 *
150 ******************************************************************************/
151
152 acpi_status
acpi_tb_acquire_table(struct acpi_table_desc * table_desc,struct acpi_table_header ** table_ptr,u32 * table_length,u8 * table_flags)153 acpi_tb_acquire_table(struct acpi_table_desc *table_desc,
154 struct acpi_table_header **table_ptr,
155 u32 *table_length, u8 *table_flags)
156 {
157 struct acpi_table_header *table = NULL;
158
159 switch (table_desc->flags & ACPI_TABLE_ORIGIN_MASK) {
160 case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
161
162 table =
163 acpi_os_map_memory(table_desc->address, table_desc->length);
164 break;
165
166 case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
167 case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
168
169 table = ACPI_CAST_PTR(struct acpi_table_header,
170 ACPI_PHYSADDR_TO_PTR(table_desc->
171 address));
172 break;
173
174 default:
175
176 break;
177 }
178
179 /* Table is not valid yet */
180
181 if (!table) {
182 return (AE_NO_MEMORY);
183 }
184
185 /* Fill the return values */
186
187 *table_ptr = table;
188 *table_length = table_desc->length;
189 *table_flags = table_desc->flags;
190 return (AE_OK);
191 }
192
193 /*******************************************************************************
194 *
195 * FUNCTION: acpi_tb_release_table
196 *
197 * PARAMETERS: table - Pointer for the table
198 * table_length - Length for the table
199 * table_flags - Allocation flags for the table
200 *
201 * RETURN: None
202 *
203 * DESCRIPTION: Release a table. The inverse of acpi_tb_acquire_table().
204 *
205 ******************************************************************************/
206
207 void
acpi_tb_release_table(struct acpi_table_header * table,u32 table_length,u8 table_flags)208 acpi_tb_release_table(struct acpi_table_header *table,
209 u32 table_length, u8 table_flags)
210 {
211
212 switch (table_flags & ACPI_TABLE_ORIGIN_MASK) {
213 case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
214
215 acpi_os_unmap_memory(table, table_length);
216 break;
217
218 case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
219 case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
220 default:
221
222 break;
223 }
224 }
225
226 /*******************************************************************************
227 *
228 * FUNCTION: acpi_tb_acquire_temp_table
229 *
230 * PARAMETERS: table_desc - Table descriptor to be acquired
231 * address - Address of the table
232 * flags - Allocation flags of the table
233 *
234 * RETURN: Status
235 *
236 * DESCRIPTION: This function validates the table header to obtain the length
237 * of a table and fills the table descriptor to make its state as
238 * "INSTALLED". Such a table descriptor is only used for verified
239 * installation.
240 *
241 ******************************************************************************/
242
243 acpi_status
acpi_tb_acquire_temp_table(struct acpi_table_desc * table_desc,acpi_physical_address address,u8 flags)244 acpi_tb_acquire_temp_table(struct acpi_table_desc *table_desc,
245 acpi_physical_address address, u8 flags)
246 {
247 struct acpi_table_header *table_header;
248
249 switch (flags & ACPI_TABLE_ORIGIN_MASK) {
250 case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
251
252 /* Get the length of the full table from the header */
253
254 table_header =
255 acpi_os_map_memory(address,
256 sizeof(struct acpi_table_header));
257 if (!table_header) {
258 return (AE_NO_MEMORY);
259 }
260
261 acpi_tb_init_table_descriptor(table_desc, address, flags,
262 table_header);
263 acpi_os_unmap_memory(table_header,
264 sizeof(struct acpi_table_header));
265 return (AE_OK);
266
267 case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
268 case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
269
270 table_header = ACPI_CAST_PTR(struct acpi_table_header,
271 ACPI_PHYSADDR_TO_PTR(address));
272 if (!table_header) {
273 return (AE_NO_MEMORY);
274 }
275
276 acpi_tb_init_table_descriptor(table_desc, address, flags,
277 table_header);
278 return (AE_OK);
279
280 default:
281
282 break;
283 }
284
285 /* Table is not valid yet */
286
287 return (AE_NO_MEMORY);
288 }
289
290 /*******************************************************************************
291 *
292 * FUNCTION: acpi_tb_release_temp_table
293 *
294 * PARAMETERS: table_desc - Table descriptor to be released
295 *
296 * RETURN: Status
297 *
298 * DESCRIPTION: The inverse of acpi_tb_acquire_temp_table().
299 *
300 *****************************************************************************/
301
acpi_tb_release_temp_table(struct acpi_table_desc * table_desc)302 void acpi_tb_release_temp_table(struct acpi_table_desc *table_desc)
303 {
304
305 /*
306 * Note that the .Address is maintained by the callers of
307 * acpi_tb_acquire_temp_table(), thus do not invoke acpi_tb_uninstall_table()
308 * where .Address will be freed.
309 */
310 acpi_tb_invalidate_table(table_desc);
311 }
312
313 /******************************************************************************
314 *
315 * FUNCTION: acpi_tb_validate_table
316 *
317 * PARAMETERS: table_desc - Table descriptor
318 *
319 * RETURN: Status
320 *
321 * DESCRIPTION: This function is called to validate the table, the returned
322 * table descriptor is in "VALIDATED" state.
323 *
324 *****************************************************************************/
325
acpi_tb_validate_table(struct acpi_table_desc * table_desc)326 acpi_status acpi_tb_validate_table(struct acpi_table_desc *table_desc)
327 {
328 acpi_status status = AE_OK;
329
330 ACPI_FUNCTION_TRACE(tb_validate_table);
331
332 /* Validate the table if necessary */
333
334 if (!table_desc->pointer) {
335 status = acpi_tb_acquire_table(table_desc, &table_desc->pointer,
336 &table_desc->length,
337 &table_desc->flags);
338 if (!table_desc->pointer) {
339 status = AE_NO_MEMORY;
340 }
341 }
342
343 return_ACPI_STATUS(status);
344 }
345
346 /*******************************************************************************
347 *
348 * FUNCTION: acpi_tb_invalidate_table
349 *
350 * PARAMETERS: table_desc - Table descriptor
351 *
352 * RETURN: None
353 *
354 * DESCRIPTION: Invalidate one internal ACPI table, this is the inverse of
355 * acpi_tb_validate_table().
356 *
357 ******************************************************************************/
358
acpi_tb_invalidate_table(struct acpi_table_desc * table_desc)359 void acpi_tb_invalidate_table(struct acpi_table_desc *table_desc)
360 {
361
362 ACPI_FUNCTION_TRACE(tb_invalidate_table);
363
364 /* Table must be validated */
365
366 if (!table_desc->pointer) {
367 return_VOID;
368 }
369
370 acpi_tb_release_table(table_desc->pointer, table_desc->length,
371 table_desc->flags);
372 table_desc->pointer = NULL;
373
374 return_VOID;
375 }
376
377 /******************************************************************************
378 *
379 * FUNCTION: acpi_tb_validate_temp_table
380 *
381 * PARAMETERS: table_desc - Table descriptor
382 *
383 * RETURN: Status
384 *
385 * DESCRIPTION: This function is called to validate the table, the returned
386 * table descriptor is in "VALIDATED" state.
387 *
388 *****************************************************************************/
389
acpi_tb_validate_temp_table(struct acpi_table_desc * table_desc)390 acpi_status acpi_tb_validate_temp_table(struct acpi_table_desc *table_desc)
391 {
392
393 if (!table_desc->pointer && !acpi_gbl_enable_table_validation) {
394 /*
395 * Only validates the header of the table.
396 * Note that Length contains the size of the mapping after invoking
397 * this work around, this value is required by
398 * acpi_tb_release_temp_table().
399 * We can do this because in acpi_init_table_descriptor(), the Length
400 * field of the installed descriptor is filled with the actual
401 * table length obtaining from the table header.
402 */
403 table_desc->length = sizeof(struct acpi_table_header);
404 }
405
406 return (acpi_tb_validate_table(table_desc));
407 }
408
409 /*******************************************************************************
410 *
411 * FUNCTION: acpi_tb_check_duplication
412 *
413 * PARAMETERS: table_desc - Table descriptor
414 * table_index - Where the table index is returned
415 *
416 * RETURN: Status
417 *
418 * DESCRIPTION: Avoid installing duplicated tables. However table override and
419 * user aided dynamic table load is allowed, thus comparing the
420 * address of the table is not sufficient, and checking the entire
421 * table content is required.
422 *
423 ******************************************************************************/
424
425 static acpi_status
acpi_tb_check_duplication(struct acpi_table_desc * table_desc,u32 * table_index)426 acpi_tb_check_duplication(struct acpi_table_desc *table_desc, u32 *table_index)
427 {
428 u32 i;
429
430 ACPI_FUNCTION_TRACE(tb_check_duplication);
431
432 /* Check if table is already registered */
433
434 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) {
435
436 /* Do not compare with unverified tables */
437
438 if (!
439 (acpi_gbl_root_table_list.tables[i].
440 flags & ACPI_TABLE_IS_VERIFIED)) {
441 continue;
442 }
443
444 /*
445 * Check for a table match on the entire table length,
446 * not just the header.
447 */
448 if (!acpi_tb_compare_tables(table_desc, i)) {
449 continue;
450 }
451
452 /*
453 * Note: the current mechanism does not unregister a table if it is
454 * dynamically unloaded. The related namespace entries are deleted,
455 * but the table remains in the root table list.
456 *
457 * The assumption here is that the number of different tables that
458 * will be loaded is actually small, and there is minimal overhead
459 * in just keeping the table in case it is needed again.
460 *
461 * If this assumption changes in the future (perhaps on large
462 * machines with many table load/unload operations), tables will
463 * need to be unregistered when they are unloaded, and slots in the
464 * root table list should be reused when empty.
465 */
466 if (acpi_gbl_root_table_list.tables[i].flags &
467 ACPI_TABLE_IS_LOADED) {
468
469 /* Table is still loaded, this is an error */
470
471 return_ACPI_STATUS(AE_ALREADY_EXISTS);
472 } else {
473 *table_index = i;
474 return_ACPI_STATUS(AE_CTRL_TERMINATE);
475 }
476 }
477
478 /* Indicate no duplication to the caller */
479
480 return_ACPI_STATUS(AE_OK);
481 }
482
483 /******************************************************************************
484 *
485 * FUNCTION: acpi_tb_verify_temp_table
486 *
487 * PARAMETERS: table_desc - Table descriptor
488 * signature - Table signature to verify
489 * table_index - Where the table index is returned
490 *
491 * RETURN: Status
492 *
493 * DESCRIPTION: This function is called to validate and verify the table, the
494 * returned table descriptor is in "VALIDATED" state.
495 * Note that 'TableIndex' is required to be set to !NULL to
496 * enable duplication check.
497 *
498 *****************************************************************************/
499
500 acpi_status
acpi_tb_verify_temp_table(struct acpi_table_desc * table_desc,char * signature,u32 * table_index)501 acpi_tb_verify_temp_table(struct acpi_table_desc *table_desc,
502 char *signature, u32 *table_index)
503 {
504 acpi_status status = AE_OK;
505
506 ACPI_FUNCTION_TRACE(tb_verify_temp_table);
507
508 /* Validate the table */
509
510 status = acpi_tb_validate_temp_table(table_desc);
511 if (ACPI_FAILURE(status)) {
512 return_ACPI_STATUS(AE_NO_MEMORY);
513 }
514
515 /* If a particular signature is expected (DSDT/FACS), it must match */
516
517 if (signature && !ACPI_COMPARE_NAME(&table_desc->signature, signature)) {
518 ACPI_BIOS_ERROR((AE_INFO,
519 "Invalid signature 0x%X for ACPI table, expected [%s]",
520 table_desc->signature.integer, signature));
521 status = AE_BAD_SIGNATURE;
522 goto invalidate_and_exit;
523 }
524
525 if (acpi_gbl_enable_table_validation) {
526
527 /* Verify the checksum */
528
529 status =
530 acpi_tb_verify_checksum(table_desc->pointer,
531 table_desc->length);
532 if (ACPI_FAILURE(status)) {
533 ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY,
534 "%4.4s 0x%8.8X%8.8X"
535 " Attempted table install failed",
536 acpi_ut_valid_nameseg(table_desc->
537 signature.
538 ascii) ?
539 table_desc->signature.ascii : "????",
540 ACPI_FORMAT_UINT64(table_desc->
541 address)));
542
543 goto invalidate_and_exit;
544 }
545
546 /* Avoid duplications */
547
548 if (table_index) {
549 status =
550 acpi_tb_check_duplication(table_desc, table_index);
551 if (ACPI_FAILURE(status)) {
552 if (status != AE_CTRL_TERMINATE) {
553 ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY,
554 "%4.4s 0x%8.8X%8.8X"
555 " Table is duplicated",
556 acpi_ut_valid_nameseg
557 (table_desc->signature.
558 ascii) ? table_desc->
559 signature.
560 ascii : "????",
561 ACPI_FORMAT_UINT64
562 (table_desc->address)));
563 }
564
565 goto invalidate_and_exit;
566 }
567 }
568
569 table_desc->flags |= ACPI_TABLE_IS_VERIFIED;
570 }
571
572 return_ACPI_STATUS(status);
573
574 invalidate_and_exit:
575 acpi_tb_invalidate_table(table_desc);
576 return_ACPI_STATUS(status);
577 }
578
579 /*******************************************************************************
580 *
581 * FUNCTION: acpi_tb_resize_root_table_list
582 *
583 * PARAMETERS: None
584 *
585 * RETURN: Status
586 *
587 * DESCRIPTION: Expand the size of global table array
588 *
589 ******************************************************************************/
590
acpi_tb_resize_root_table_list(void)591 acpi_status acpi_tb_resize_root_table_list(void)
592 {
593 struct acpi_table_desc *tables;
594 u32 table_count;
595 u32 current_table_count, max_table_count;
596 u32 i;
597
598 ACPI_FUNCTION_TRACE(tb_resize_root_table_list);
599
600 /* allow_resize flag is a parameter to acpi_initialize_tables */
601
602 if (!(acpi_gbl_root_table_list.flags & ACPI_ROOT_ALLOW_RESIZE)) {
603 ACPI_ERROR((AE_INFO,
604 "Resize of Root Table Array is not allowed"));
605 return_ACPI_STATUS(AE_SUPPORT);
606 }
607
608 /* Increase the Table Array size */
609
610 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
611 table_count = acpi_gbl_root_table_list.max_table_count;
612 } else {
613 table_count = acpi_gbl_root_table_list.current_table_count;
614 }
615
616 max_table_count = table_count + ACPI_ROOT_TABLE_SIZE_INCREMENT;
617 tables = ACPI_ALLOCATE_ZEROED(((acpi_size)max_table_count) *
618 sizeof(struct acpi_table_desc));
619 if (!tables) {
620 ACPI_ERROR((AE_INFO,
621 "Could not allocate new root table array"));
622 return_ACPI_STATUS(AE_NO_MEMORY);
623 }
624
625 /* Copy and free the previous table array */
626
627 current_table_count = 0;
628 if (acpi_gbl_root_table_list.tables) {
629 for (i = 0; i < table_count; i++) {
630 if (acpi_gbl_root_table_list.tables[i].address) {
631 memcpy(tables + current_table_count,
632 acpi_gbl_root_table_list.tables + i,
633 sizeof(struct acpi_table_desc));
634 current_table_count++;
635 }
636 }
637
638 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
639 ACPI_FREE(acpi_gbl_root_table_list.tables);
640 }
641 }
642
643 acpi_gbl_root_table_list.tables = tables;
644 acpi_gbl_root_table_list.max_table_count = max_table_count;
645 acpi_gbl_root_table_list.current_table_count = current_table_count;
646 acpi_gbl_root_table_list.flags |= ACPI_ROOT_ORIGIN_ALLOCATED;
647
648 return_ACPI_STATUS(AE_OK);
649 }
650
651 /*******************************************************************************
652 *
653 * FUNCTION: acpi_tb_get_next_table_descriptor
654 *
655 * PARAMETERS: table_index - Where table index is returned
656 * table_desc - Where table descriptor is returned
657 *
658 * RETURN: Status and table index/descriptor.
659 *
660 * DESCRIPTION: Allocate a new ACPI table entry to the global table list
661 *
662 ******************************************************************************/
663
664 acpi_status
acpi_tb_get_next_table_descriptor(u32 * table_index,struct acpi_table_desc ** table_desc)665 acpi_tb_get_next_table_descriptor(u32 *table_index,
666 struct acpi_table_desc **table_desc)
667 {
668 acpi_status status;
669 u32 i;
670
671 /* Ensure that there is room for the table in the Root Table List */
672
673 if (acpi_gbl_root_table_list.current_table_count >=
674 acpi_gbl_root_table_list.max_table_count) {
675 status = acpi_tb_resize_root_table_list();
676 if (ACPI_FAILURE(status)) {
677 return (status);
678 }
679 }
680
681 i = acpi_gbl_root_table_list.current_table_count;
682 acpi_gbl_root_table_list.current_table_count++;
683
684 if (table_index) {
685 *table_index = i;
686 }
687 if (table_desc) {
688 *table_desc = &acpi_gbl_root_table_list.tables[i];
689 }
690
691 return (AE_OK);
692 }
693
694 /*******************************************************************************
695 *
696 * FUNCTION: acpi_tb_terminate
697 *
698 * PARAMETERS: None
699 *
700 * RETURN: None
701 *
702 * DESCRIPTION: Delete all internal ACPI tables
703 *
704 ******************************************************************************/
705
acpi_tb_terminate(void)706 void acpi_tb_terminate(void)
707 {
708 u32 i;
709
710 ACPI_FUNCTION_TRACE(tb_terminate);
711
712 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
713
714 /* Delete the individual tables */
715
716 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) {
717 acpi_tb_uninstall_table(&acpi_gbl_root_table_list.tables[i]);
718 }
719
720 /*
721 * Delete the root table array if allocated locally. Array cannot be
722 * mapped, so we don't need to check for that flag.
723 */
724 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
725 ACPI_FREE(acpi_gbl_root_table_list.tables);
726 }
727
728 acpi_gbl_root_table_list.tables = NULL;
729 acpi_gbl_root_table_list.flags = 0;
730 acpi_gbl_root_table_list.current_table_count = 0;
731
732 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "ACPI Tables freed\n"));
733
734 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
735 return_VOID;
736 }
737
738 /*******************************************************************************
739 *
740 * FUNCTION: acpi_tb_delete_namespace_by_owner
741 *
742 * PARAMETERS: table_index - Table index
743 *
744 * RETURN: Status
745 *
746 * DESCRIPTION: Delete all namespace objects created when this table was loaded.
747 *
748 ******************************************************************************/
749
acpi_tb_delete_namespace_by_owner(u32 table_index)750 acpi_status acpi_tb_delete_namespace_by_owner(u32 table_index)
751 {
752 acpi_owner_id owner_id;
753 acpi_status status;
754
755 ACPI_FUNCTION_TRACE(tb_delete_namespace_by_owner);
756
757 status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
758 if (ACPI_FAILURE(status)) {
759 return_ACPI_STATUS(status);
760 }
761
762 if (table_index >= acpi_gbl_root_table_list.current_table_count) {
763
764 /* The table index does not exist */
765
766 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
767 return_ACPI_STATUS(AE_NOT_EXIST);
768 }
769
770 /* Get the owner ID for this table, used to delete namespace nodes */
771
772 owner_id = acpi_gbl_root_table_list.tables[table_index].owner_id;
773 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
774
775 /*
776 * Need to acquire the namespace writer lock to prevent interference
777 * with any concurrent namespace walks. The interpreter must be
778 * released during the deletion since the acquisition of the deletion
779 * lock may block, and also since the execution of a namespace walk
780 * must be allowed to use the interpreter.
781 */
782 status = acpi_ut_acquire_write_lock(&acpi_gbl_namespace_rw_lock);
783 if (ACPI_FAILURE(status)) {
784 return_ACPI_STATUS(status);
785 }
786 acpi_ns_delete_namespace_by_owner(owner_id);
787 acpi_ut_release_write_lock(&acpi_gbl_namespace_rw_lock);
788 return_ACPI_STATUS(status);
789 }
790
791 /*******************************************************************************
792 *
793 * FUNCTION: acpi_tb_allocate_owner_id
794 *
795 * PARAMETERS: table_index - Table index
796 *
797 * RETURN: Status
798 *
799 * DESCRIPTION: Allocates owner_id in table_desc
800 *
801 ******************************************************************************/
802
acpi_tb_allocate_owner_id(u32 table_index)803 acpi_status acpi_tb_allocate_owner_id(u32 table_index)
804 {
805 acpi_status status = AE_BAD_PARAMETER;
806
807 ACPI_FUNCTION_TRACE(tb_allocate_owner_id);
808
809 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
810 if (table_index < acpi_gbl_root_table_list.current_table_count) {
811 status =
812 acpi_ut_allocate_owner_id(&
813 (acpi_gbl_root_table_list.
814 tables[table_index].owner_id));
815 }
816
817 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
818 return_ACPI_STATUS(status);
819 }
820
821 /*******************************************************************************
822 *
823 * FUNCTION: acpi_tb_release_owner_id
824 *
825 * PARAMETERS: table_index - Table index
826 *
827 * RETURN: Status
828 *
829 * DESCRIPTION: Releases owner_id in table_desc
830 *
831 ******************************************************************************/
832
acpi_tb_release_owner_id(u32 table_index)833 acpi_status acpi_tb_release_owner_id(u32 table_index)
834 {
835 acpi_status status = AE_BAD_PARAMETER;
836
837 ACPI_FUNCTION_TRACE(tb_release_owner_id);
838
839 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
840 if (table_index < acpi_gbl_root_table_list.current_table_count) {
841 acpi_ut_release_owner_id(&
842 (acpi_gbl_root_table_list.
843 tables[table_index].owner_id));
844 status = AE_OK;
845 }
846
847 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
848 return_ACPI_STATUS(status);
849 }
850
851 /*******************************************************************************
852 *
853 * FUNCTION: acpi_tb_get_owner_id
854 *
855 * PARAMETERS: table_index - Table index
856 * owner_id - Where the table owner_id is returned
857 *
858 * RETURN: Status
859 *
860 * DESCRIPTION: returns owner_id for the ACPI table
861 *
862 ******************************************************************************/
863
acpi_tb_get_owner_id(u32 table_index,acpi_owner_id * owner_id)864 acpi_status acpi_tb_get_owner_id(u32 table_index, acpi_owner_id *owner_id)
865 {
866 acpi_status status = AE_BAD_PARAMETER;
867
868 ACPI_FUNCTION_TRACE(tb_get_owner_id);
869
870 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
871 if (table_index < acpi_gbl_root_table_list.current_table_count) {
872 *owner_id =
873 acpi_gbl_root_table_list.tables[table_index].owner_id;
874 status = AE_OK;
875 }
876
877 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
878 return_ACPI_STATUS(status);
879 }
880
881 /*******************************************************************************
882 *
883 * FUNCTION: acpi_tb_is_table_loaded
884 *
885 * PARAMETERS: table_index - Index into the root table
886 *
887 * RETURN: Table Loaded Flag
888 *
889 ******************************************************************************/
890
acpi_tb_is_table_loaded(u32 table_index)891 u8 acpi_tb_is_table_loaded(u32 table_index)
892 {
893 u8 is_loaded = FALSE;
894
895 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
896 if (table_index < acpi_gbl_root_table_list.current_table_count) {
897 is_loaded = (u8)
898 (acpi_gbl_root_table_list.tables[table_index].flags &
899 ACPI_TABLE_IS_LOADED);
900 }
901
902 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
903 return (is_loaded);
904 }
905
906 /*******************************************************************************
907 *
908 * FUNCTION: acpi_tb_set_table_loaded_flag
909 *
910 * PARAMETERS: table_index - Table index
911 * is_loaded - TRUE if table is loaded, FALSE otherwise
912 *
913 * RETURN: None
914 *
915 * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE.
916 *
917 ******************************************************************************/
918
acpi_tb_set_table_loaded_flag(u32 table_index,u8 is_loaded)919 void acpi_tb_set_table_loaded_flag(u32 table_index, u8 is_loaded)
920 {
921
922 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
923 if (table_index < acpi_gbl_root_table_list.current_table_count) {
924 if (is_loaded) {
925 acpi_gbl_root_table_list.tables[table_index].flags |=
926 ACPI_TABLE_IS_LOADED;
927 } else {
928 acpi_gbl_root_table_list.tables[table_index].flags &=
929 ~ACPI_TABLE_IS_LOADED;
930 }
931 }
932
933 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
934 }
935
936 /*******************************************************************************
937 *
938 * FUNCTION: acpi_tb_load_table
939 *
940 * PARAMETERS: table_index - Table index
941 * parent_node - Where table index is returned
942 *
943 * RETURN: Status
944 *
945 * DESCRIPTION: Load an ACPI table
946 *
947 ******************************************************************************/
948
949 acpi_status
acpi_tb_load_table(u32 table_index,struct acpi_namespace_node * parent_node)950 acpi_tb_load_table(u32 table_index, struct acpi_namespace_node *parent_node)
951 {
952 struct acpi_table_header *table;
953 acpi_status status;
954 acpi_owner_id owner_id;
955
956 ACPI_FUNCTION_TRACE(tb_load_table);
957
958 /*
959 * Note: Now table is "INSTALLED", it must be validated before
960 * using.
961 */
962 status = acpi_get_table_by_index(table_index, &table);
963 if (ACPI_FAILURE(status)) {
964 return_ACPI_STATUS(status);
965 }
966
967 status = acpi_ns_load_table(table_index, parent_node);
968
969 /* Execute any module-level code that was found in the table */
970
971 if (!acpi_gbl_parse_table_as_term_list
972 && acpi_gbl_group_module_level_code) {
973 acpi_ns_exec_module_code_list();
974 }
975
976 /*
977 * Update GPEs for any new _Lxx/_Exx methods. Ignore errors. The host is
978 * responsible for discovering any new wake GPEs by running _PRW methods
979 * that may have been loaded by this table.
980 */
981 status = acpi_tb_get_owner_id(table_index, &owner_id);
982 if (ACPI_SUCCESS(status)) {
983 acpi_ev_update_gpes(owner_id);
984 }
985
986 /* Invoke table handler */
987
988 acpi_tb_notify_table(ACPI_TABLE_EVENT_LOAD, table);
989 return_ACPI_STATUS(status);
990 }
991
992 /*******************************************************************************
993 *
994 * FUNCTION: acpi_tb_install_and_load_table
995 *
996 * PARAMETERS: address - Physical address of the table
997 * flags - Allocation flags of the table
998 * override - Whether override should be performed
999 * table_index - Where table index is returned
1000 *
1001 * RETURN: Status
1002 *
1003 * DESCRIPTION: Install and load an ACPI table
1004 *
1005 ******************************************************************************/
1006
1007 acpi_status
acpi_tb_install_and_load_table(acpi_physical_address address,u8 flags,u8 override,u32 * table_index)1008 acpi_tb_install_and_load_table(acpi_physical_address address,
1009 u8 flags, u8 override, u32 *table_index)
1010 {
1011 acpi_status status;
1012 u32 i;
1013
1014 ACPI_FUNCTION_TRACE(tb_install_and_load_table);
1015
1016 /* Install the table and load it into the namespace */
1017
1018 status = acpi_tb_install_standard_table(address, flags, TRUE,
1019 override, &i);
1020 if (ACPI_FAILURE(status)) {
1021 goto exit;
1022 }
1023
1024 status = acpi_tb_load_table(i, acpi_gbl_root_node);
1025
1026 exit:
1027 *table_index = i;
1028 return_ACPI_STATUS(status);
1029 }
1030
ACPI_EXPORT_SYMBOL(acpi_tb_install_and_load_table)1031 ACPI_EXPORT_SYMBOL(acpi_tb_install_and_load_table)
1032
1033 /*******************************************************************************
1034 *
1035 * FUNCTION: acpi_tb_unload_table
1036 *
1037 * PARAMETERS: table_index - Table index
1038 *
1039 * RETURN: Status
1040 *
1041 * DESCRIPTION: Unload an ACPI table
1042 *
1043 ******************************************************************************/
1044
1045 acpi_status acpi_tb_unload_table(u32 table_index)
1046 {
1047 acpi_status status = AE_OK;
1048 struct acpi_table_header *table;
1049
1050 ACPI_FUNCTION_TRACE(tb_unload_table);
1051
1052 /* Ensure the table is still loaded */
1053
1054 if (!acpi_tb_is_table_loaded(table_index)) {
1055 return_ACPI_STATUS(AE_NOT_EXIST);
1056 }
1057
1058 /* Invoke table handler */
1059
1060 status = acpi_get_table_by_index(table_index, &table);
1061 if (ACPI_SUCCESS(status)) {
1062 acpi_tb_notify_table(ACPI_TABLE_EVENT_UNLOAD, table);
1063 }
1064
1065 /* Delete the portion of the namespace owned by this table */
1066
1067 status = acpi_tb_delete_namespace_by_owner(table_index);
1068 if (ACPI_FAILURE(status)) {
1069 return_ACPI_STATUS(status);
1070 }
1071
1072 (void)acpi_tb_release_owner_id(table_index);
1073 acpi_tb_set_table_loaded_flag(table_index, FALSE);
1074 return_ACPI_STATUS(status);
1075 }
1076
ACPI_EXPORT_SYMBOL(acpi_tb_unload_table)1077 ACPI_EXPORT_SYMBOL(acpi_tb_unload_table)
1078
1079 /*******************************************************************************
1080 *
1081 * FUNCTION: acpi_tb_notify_table
1082 *
1083 * PARAMETERS: event - Table event
1084 * table - Validated table pointer
1085 *
1086 * RETURN: None
1087 *
1088 * DESCRIPTION: Notify a table event to the users.
1089 *
1090 ******************************************************************************/
1091
1092 void acpi_tb_notify_table(u32 event, void *table)
1093 {
1094 /* Invoke table handler if present */
1095
1096 if (acpi_gbl_table_handler) {
1097 (void)acpi_gbl_table_handler(event, table,
1098 acpi_gbl_table_handler_context);
1099 }
1100 }
1101