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