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