1 /****************************************************************************** 2 * 3 * Module Name: tbdata - Table manager data structure functions 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2016, 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.h" 45 #include "accommon.h" 46 #include "acnamesp.h" 47 #include "actables.h" 48 49 #define _COMPONENT ACPI_TABLES 50 ACPI_MODULE_NAME ("tbdata") 51 52 53 /******************************************************************************* 54 * 55 * FUNCTION: AcpiTbInitTableDescriptor 56 * 57 * PARAMETERS: TableDesc - 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 68 void 69 AcpiTbInitTableDescriptor ( 70 ACPI_TABLE_DESC *TableDesc, 71 ACPI_PHYSICAL_ADDRESS Address, 72 UINT8 Flags, 73 ACPI_TABLE_HEADER *Table) 74 { 75 76 /* 77 * Initialize the table descriptor. Set the pointer to NULL, since the 78 * table is not fully mapped at this time. 79 */ 80 memset (TableDesc, 0, sizeof (ACPI_TABLE_DESC)); 81 TableDesc->Address = Address; 82 TableDesc->Length = Table->Length; 83 TableDesc->Flags = Flags; 84 ACPI_MOVE_32_TO_32 (TableDesc->Signature.Ascii, Table->Signature); 85 } 86 87 88 /******************************************************************************* 89 * 90 * FUNCTION: AcpiTbAcquireTable 91 * 92 * PARAMETERS: TableDesc - Table descriptor 93 * TablePtr - Where table is returned 94 * TableLength - Where table length is returned 95 * TableFlags - Where table allocation flags are returned 96 * 97 * RETURN: Status 98 * 99 * DESCRIPTION: Acquire an ACPI table. It can be used for tables not 100 * maintained in the AcpiGbl_RootTableList. 101 * 102 ******************************************************************************/ 103 104 ACPI_STATUS 105 AcpiTbAcquireTable ( 106 ACPI_TABLE_DESC *TableDesc, 107 ACPI_TABLE_HEADER **TablePtr, 108 UINT32 *TableLength, 109 UINT8 *TableFlags) 110 { 111 ACPI_TABLE_HEADER *Table = NULL; 112 113 114 switch (TableDesc->Flags & ACPI_TABLE_ORIGIN_MASK) 115 { 116 case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL: 117 118 Table = AcpiOsMapMemory (TableDesc->Address, TableDesc->Length); 119 break; 120 121 case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL: 122 case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL: 123 124 Table = ACPI_CAST_PTR (ACPI_TABLE_HEADER, 125 ACPI_PHYSADDR_TO_PTR (TableDesc->Address)); 126 break; 127 128 default: 129 130 break; 131 } 132 133 /* Table is not valid yet */ 134 135 if (!Table) 136 { 137 return (AE_NO_MEMORY); 138 } 139 140 /* Fill the return values */ 141 142 *TablePtr = Table; 143 *TableLength = TableDesc->Length; 144 *TableFlags = TableDesc->Flags; 145 return (AE_OK); 146 } 147 148 149 /******************************************************************************* 150 * 151 * FUNCTION: AcpiTbReleaseTable 152 * 153 * PARAMETERS: Table - Pointer for the table 154 * TableLength - Length for the table 155 * TableFlags - Allocation flags for the table 156 * 157 * RETURN: None 158 * 159 * DESCRIPTION: Release a table. The inverse of AcpiTbAcquireTable(). 160 * 161 ******************************************************************************/ 162 163 void 164 AcpiTbReleaseTable ( 165 ACPI_TABLE_HEADER *Table, 166 UINT32 TableLength, 167 UINT8 TableFlags) 168 { 169 170 switch (TableFlags & ACPI_TABLE_ORIGIN_MASK) 171 { 172 case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL: 173 174 AcpiOsUnmapMemory (Table, TableLength); 175 break; 176 177 case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL: 178 case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL: 179 default: 180 181 break; 182 } 183 } 184 185 186 /******************************************************************************* 187 * 188 * FUNCTION: AcpiTbAcquireTempTable 189 * 190 * PARAMETERS: TableDesc - Table descriptor to be acquired 191 * Address - Address of the table 192 * Flags - Allocation flags of the table 193 * 194 * RETURN: Status 195 * 196 * DESCRIPTION: This function validates the table header to obtain the length 197 * of a table and fills the table descriptor to make its state as 198 * "INSTALLED". Such a table descriptor is only used for verified 199 * installation. 200 * 201 ******************************************************************************/ 202 203 ACPI_STATUS 204 AcpiTbAcquireTempTable ( 205 ACPI_TABLE_DESC *TableDesc, 206 ACPI_PHYSICAL_ADDRESS Address, 207 UINT8 Flags) 208 { 209 ACPI_TABLE_HEADER *TableHeader; 210 211 212 switch (Flags & ACPI_TABLE_ORIGIN_MASK) 213 { 214 case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL: 215 216 /* Get the length of the full table from the header */ 217 218 TableHeader = AcpiOsMapMemory (Address, sizeof (ACPI_TABLE_HEADER)); 219 if (!TableHeader) 220 { 221 return (AE_NO_MEMORY); 222 } 223 224 AcpiTbInitTableDescriptor (TableDesc, Address, Flags, TableHeader); 225 AcpiOsUnmapMemory (TableHeader, sizeof (ACPI_TABLE_HEADER)); 226 return (AE_OK); 227 228 case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL: 229 case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL: 230 231 TableHeader = ACPI_CAST_PTR (ACPI_TABLE_HEADER, 232 ACPI_PHYSADDR_TO_PTR (Address)); 233 if (!TableHeader) 234 { 235 return (AE_NO_MEMORY); 236 } 237 238 AcpiTbInitTableDescriptor (TableDesc, Address, Flags, TableHeader); 239 return (AE_OK); 240 241 default: 242 243 break; 244 } 245 246 /* Table is not valid yet */ 247 248 return (AE_NO_MEMORY); 249 } 250 251 252 /******************************************************************************* 253 * 254 * FUNCTION: AcpiTbReleaseTempTable 255 * 256 * PARAMETERS: TableDesc - Table descriptor to be released 257 * 258 * RETURN: Status 259 * 260 * DESCRIPTION: The inverse of AcpiTbAcquireTempTable(). 261 * 262 *****************************************************************************/ 263 264 void 265 AcpiTbReleaseTempTable ( 266 ACPI_TABLE_DESC *TableDesc) 267 { 268 269 /* 270 * Note that the .Address is maintained by the callers of 271 * AcpiTbAcquireTempTable(), thus do not invoke AcpiTbUninstallTable() 272 * where .Address will be freed. 273 */ 274 AcpiTbInvalidateTable (TableDesc); 275 } 276 277 278 /****************************************************************************** 279 * 280 * FUNCTION: AcpiTbValidateTable 281 * 282 * PARAMETERS: TableDesc - Table descriptor 283 * 284 * RETURN: Status 285 * 286 * DESCRIPTION: This function is called to validate the table, the returned 287 * table descriptor is in "VALIDATED" state. 288 * 289 *****************************************************************************/ 290 291 ACPI_STATUS 292 AcpiTbValidateTable ( 293 ACPI_TABLE_DESC *TableDesc) 294 { 295 ACPI_STATUS Status = AE_OK; 296 297 298 ACPI_FUNCTION_TRACE (TbValidateTable); 299 300 301 /* Validate the table if necessary */ 302 303 if (!TableDesc->Pointer) 304 { 305 Status = AcpiTbAcquireTable (TableDesc, &TableDesc->Pointer, 306 &TableDesc->Length, &TableDesc->Flags); 307 if (!TableDesc->Pointer) 308 { 309 Status = AE_NO_MEMORY; 310 } 311 } 312 313 return_ACPI_STATUS (Status); 314 } 315 316 317 /******************************************************************************* 318 * 319 * FUNCTION: AcpiTbInvalidateTable 320 * 321 * PARAMETERS: TableDesc - Table descriptor 322 * 323 * RETURN: None 324 * 325 * DESCRIPTION: Invalidate one internal ACPI table, this is the inverse of 326 * AcpiTbValidateTable(). 327 * 328 ******************************************************************************/ 329 330 void 331 AcpiTbInvalidateTable ( 332 ACPI_TABLE_DESC *TableDesc) 333 { 334 335 ACPI_FUNCTION_TRACE (TbInvalidateTable); 336 337 338 /* Table must be validated */ 339 340 if (!TableDesc->Pointer) 341 { 342 return_VOID; 343 } 344 345 AcpiTbReleaseTable (TableDesc->Pointer, TableDesc->Length, 346 TableDesc->Flags); 347 TableDesc->Pointer = NULL; 348 349 return_VOID; 350 } 351 352 353 /****************************************************************************** 354 * 355 * FUNCTION: AcpiTbValidateTempTable 356 * 357 * PARAMETERS: TableDesc - Table descriptor 358 * 359 * RETURN: Status 360 * 361 * DESCRIPTION: This function is called to validate the table, the returned 362 * table descriptor is in "VALIDATED" state. 363 * 364 *****************************************************************************/ 365 366 ACPI_STATUS 367 AcpiTbValidateTempTable ( 368 ACPI_TABLE_DESC *TableDesc) 369 { 370 371 if (!TableDesc->Pointer && !AcpiGbl_VerifyTableChecksum) 372 { 373 /* 374 * Only validates the header of the table. 375 * Note that Length contains the size of the mapping after invoking 376 * this work around, this value is required by 377 * AcpiTbReleaseTempTable(). 378 * We can do this because in AcpiInitTableDescriptor(), the Length 379 * field of the installed descriptor is filled with the actual 380 * table length obtaining from the table header. 381 */ 382 TableDesc->Length = sizeof (ACPI_TABLE_HEADER); 383 } 384 385 return (AcpiTbValidateTable (TableDesc)); 386 } 387 388 389 /****************************************************************************** 390 * 391 * FUNCTION: AcpiTbVerifyTempTable 392 * 393 * PARAMETERS: TableDesc - Table descriptor 394 * Signature - Table signature to verify 395 * 396 * RETURN: Status 397 * 398 * DESCRIPTION: This function is called to validate and verify the table, the 399 * returned table descriptor is in "VALIDATED" state. 400 * 401 *****************************************************************************/ 402 403 ACPI_STATUS 404 AcpiTbVerifyTempTable ( 405 ACPI_TABLE_DESC *TableDesc, 406 char *Signature) 407 { 408 ACPI_STATUS Status = AE_OK; 409 410 411 ACPI_FUNCTION_TRACE (TbVerifyTempTable); 412 413 414 /* Validate the table */ 415 416 Status = AcpiTbValidateTempTable (TableDesc); 417 if (ACPI_FAILURE (Status)) 418 { 419 return_ACPI_STATUS (AE_NO_MEMORY); 420 } 421 422 /* If a particular signature is expected (DSDT/FACS), it must match */ 423 424 if (Signature && 425 !ACPI_COMPARE_NAME (&TableDesc->Signature, Signature)) 426 { 427 ACPI_BIOS_ERROR ((AE_INFO, 428 "Invalid signature 0x%X for ACPI table, expected [%s]", 429 TableDesc->Signature.Integer, Signature)); 430 Status = AE_BAD_SIGNATURE; 431 goto InvalidateAndExit; 432 } 433 434 /* Verify the checksum */ 435 436 if (AcpiGbl_VerifyTableChecksum) 437 { 438 Status = AcpiTbVerifyChecksum (TableDesc->Pointer, TableDesc->Length); 439 if (ACPI_FAILURE (Status)) 440 { 441 ACPI_EXCEPTION ((AE_INFO, AE_NO_MEMORY, 442 "%4.4s 0x%8.8X%8.8X" 443 " Attempted table install failed", 444 AcpiUtValidNameseg (TableDesc->Signature.Ascii) ? 445 TableDesc->Signature.Ascii : "????", 446 ACPI_FORMAT_UINT64 (TableDesc->Address))); 447 448 goto InvalidateAndExit; 449 } 450 } 451 452 return_ACPI_STATUS (AE_OK); 453 454 InvalidateAndExit: 455 AcpiTbInvalidateTable (TableDesc); 456 return_ACPI_STATUS (Status); 457 } 458 459 460 /******************************************************************************* 461 * 462 * FUNCTION: AcpiTbResizeRootTableList 463 * 464 * PARAMETERS: None 465 * 466 * RETURN: Status 467 * 468 * DESCRIPTION: Expand the size of global table array 469 * 470 ******************************************************************************/ 471 472 ACPI_STATUS 473 AcpiTbResizeRootTableList ( 474 void) 475 { 476 ACPI_TABLE_DESC *Tables; 477 UINT32 TableCount; 478 479 480 ACPI_FUNCTION_TRACE (TbResizeRootTableList); 481 482 483 /* AllowResize flag is a parameter to AcpiInitializeTables */ 484 485 if (!(AcpiGbl_RootTableList.Flags & ACPI_ROOT_ALLOW_RESIZE)) 486 { 487 ACPI_ERROR ((AE_INFO, "Resize of Root Table Array is not allowed")); 488 return_ACPI_STATUS (AE_SUPPORT); 489 } 490 491 /* Increase the Table Array size */ 492 493 if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED) 494 { 495 TableCount = AcpiGbl_RootTableList.MaxTableCount; 496 } 497 else 498 { 499 TableCount = AcpiGbl_RootTableList.CurrentTableCount; 500 } 501 502 Tables = ACPI_ALLOCATE_ZEROED ( 503 ((ACPI_SIZE) TableCount + ACPI_ROOT_TABLE_SIZE_INCREMENT) * 504 sizeof (ACPI_TABLE_DESC)); 505 if (!Tables) 506 { 507 ACPI_ERROR ((AE_INFO, "Could not allocate new root table array")); 508 return_ACPI_STATUS (AE_NO_MEMORY); 509 } 510 511 /* Copy and free the previous table array */ 512 513 if (AcpiGbl_RootTableList.Tables) 514 { 515 memcpy (Tables, AcpiGbl_RootTableList.Tables, 516 (ACPI_SIZE) TableCount * sizeof (ACPI_TABLE_DESC)); 517 518 if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED) 519 { 520 ACPI_FREE (AcpiGbl_RootTableList.Tables); 521 } 522 } 523 524 AcpiGbl_RootTableList.Tables = Tables; 525 AcpiGbl_RootTableList.MaxTableCount = 526 TableCount + ACPI_ROOT_TABLE_SIZE_INCREMENT; 527 AcpiGbl_RootTableList.Flags |= ACPI_ROOT_ORIGIN_ALLOCATED; 528 529 return_ACPI_STATUS (AE_OK); 530 } 531 532 533 /******************************************************************************* 534 * 535 * FUNCTION: AcpiTbGetNextTableDescriptor 536 * 537 * PARAMETERS: TableIndex - Where table index is returned 538 * TableDesc - Where table descriptor is returned 539 * 540 * RETURN: Status and table index/descriptor. 541 * 542 * DESCRIPTION: Allocate a new ACPI table entry to the global table list 543 * 544 ******************************************************************************/ 545 546 ACPI_STATUS 547 AcpiTbGetNextTableDescriptor ( 548 UINT32 *TableIndex, 549 ACPI_TABLE_DESC **TableDesc) 550 { 551 ACPI_STATUS Status; 552 UINT32 i; 553 554 555 /* Ensure that there is room for the table in the Root Table List */ 556 557 if (AcpiGbl_RootTableList.CurrentTableCount >= 558 AcpiGbl_RootTableList.MaxTableCount) 559 { 560 Status = AcpiTbResizeRootTableList(); 561 if (ACPI_FAILURE (Status)) 562 { 563 return (Status); 564 } 565 } 566 567 i = AcpiGbl_RootTableList.CurrentTableCount; 568 AcpiGbl_RootTableList.CurrentTableCount++; 569 570 if (TableIndex) 571 { 572 *TableIndex = i; 573 } 574 if (TableDesc) 575 { 576 *TableDesc = &AcpiGbl_RootTableList.Tables[i]; 577 } 578 579 return (AE_OK); 580 } 581 582 583 /******************************************************************************* 584 * 585 * FUNCTION: AcpiTbTerminate 586 * 587 * PARAMETERS: None 588 * 589 * RETURN: None 590 * 591 * DESCRIPTION: Delete all internal ACPI tables 592 * 593 ******************************************************************************/ 594 595 void 596 AcpiTbTerminate ( 597 void) 598 { 599 UINT32 i; 600 601 602 ACPI_FUNCTION_TRACE (TbTerminate); 603 604 605 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 606 607 /* Delete the individual tables */ 608 609 for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++) 610 { 611 AcpiTbUninstallTable (&AcpiGbl_RootTableList.Tables[i]); 612 } 613 614 /* 615 * Delete the root table array if allocated locally. Array cannot be 616 * mapped, so we don't need to check for that flag. 617 */ 618 if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED) 619 { 620 ACPI_FREE (AcpiGbl_RootTableList.Tables); 621 } 622 623 AcpiGbl_RootTableList.Tables = NULL; 624 AcpiGbl_RootTableList.Flags = 0; 625 AcpiGbl_RootTableList.CurrentTableCount = 0; 626 627 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ACPI Tables freed\n")); 628 629 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 630 return_VOID; 631 } 632 633 634 /******************************************************************************* 635 * 636 * FUNCTION: AcpiTbDeleteNamespaceByOwner 637 * 638 * PARAMETERS: TableIndex - Table index 639 * 640 * RETURN: Status 641 * 642 * DESCRIPTION: Delete all namespace objects created when this table was loaded. 643 * 644 ******************************************************************************/ 645 646 ACPI_STATUS 647 AcpiTbDeleteNamespaceByOwner ( 648 UINT32 TableIndex) 649 { 650 ACPI_OWNER_ID OwnerId; 651 ACPI_STATUS Status; 652 653 654 ACPI_FUNCTION_TRACE (TbDeleteNamespaceByOwner); 655 656 657 Status = AcpiUtAcquireMutex (ACPI_MTX_TABLES); 658 if (ACPI_FAILURE (Status)) 659 { 660 return_ACPI_STATUS (Status); 661 } 662 663 if (TableIndex >= AcpiGbl_RootTableList.CurrentTableCount) 664 { 665 /* The table index does not exist */ 666 667 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 668 return_ACPI_STATUS (AE_NOT_EXIST); 669 } 670 671 /* Get the owner ID for this table, used to delete namespace nodes */ 672 673 OwnerId = AcpiGbl_RootTableList.Tables[TableIndex].OwnerId; 674 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 675 676 /* 677 * Need to acquire the namespace writer lock to prevent interference 678 * with any concurrent namespace walks. The interpreter must be 679 * released during the deletion since the acquisition of the deletion 680 * lock may block, and also since the execution of a namespace walk 681 * must be allowed to use the interpreter. 682 */ 683 (void) AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER); 684 Status = AcpiUtAcquireWriteLock (&AcpiGbl_NamespaceRwLock); 685 686 AcpiNsDeleteNamespaceByOwner (OwnerId); 687 if (ACPI_FAILURE (Status)) 688 { 689 return_ACPI_STATUS (Status); 690 } 691 692 AcpiUtReleaseWriteLock (&AcpiGbl_NamespaceRwLock); 693 694 Status = AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER); 695 return_ACPI_STATUS (Status); 696 } 697 698 699 /******************************************************************************* 700 * 701 * FUNCTION: AcpiTbAllocateOwnerId 702 * 703 * PARAMETERS: TableIndex - Table index 704 * 705 * RETURN: Status 706 * 707 * DESCRIPTION: Allocates OwnerId in TableDesc 708 * 709 ******************************************************************************/ 710 711 ACPI_STATUS 712 AcpiTbAllocateOwnerId ( 713 UINT32 TableIndex) 714 { 715 ACPI_STATUS Status = AE_BAD_PARAMETER; 716 717 718 ACPI_FUNCTION_TRACE (TbAllocateOwnerId); 719 720 721 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 722 if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) 723 { 724 Status = AcpiUtAllocateOwnerId ( 725 &(AcpiGbl_RootTableList.Tables[TableIndex].OwnerId)); 726 } 727 728 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 729 return_ACPI_STATUS (Status); 730 } 731 732 733 /******************************************************************************* 734 * 735 * FUNCTION: AcpiTbReleaseOwnerId 736 * 737 * PARAMETERS: TableIndex - Table index 738 * 739 * RETURN: Status 740 * 741 * DESCRIPTION: Releases OwnerId in TableDesc 742 * 743 ******************************************************************************/ 744 745 ACPI_STATUS 746 AcpiTbReleaseOwnerId ( 747 UINT32 TableIndex) 748 { 749 ACPI_STATUS Status = AE_BAD_PARAMETER; 750 751 752 ACPI_FUNCTION_TRACE (TbReleaseOwnerId); 753 754 755 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 756 if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) 757 { 758 AcpiUtReleaseOwnerId ( 759 &(AcpiGbl_RootTableList.Tables[TableIndex].OwnerId)); 760 Status = AE_OK; 761 } 762 763 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 764 return_ACPI_STATUS (Status); 765 } 766 767 768 /******************************************************************************* 769 * 770 * FUNCTION: AcpiTbGetOwnerId 771 * 772 * PARAMETERS: TableIndex - Table index 773 * OwnerId - Where the table OwnerId is returned 774 * 775 * RETURN: Status 776 * 777 * DESCRIPTION: returns OwnerId for the ACPI table 778 * 779 ******************************************************************************/ 780 781 ACPI_STATUS 782 AcpiTbGetOwnerId ( 783 UINT32 TableIndex, 784 ACPI_OWNER_ID *OwnerId) 785 { 786 ACPI_STATUS Status = AE_BAD_PARAMETER; 787 788 789 ACPI_FUNCTION_TRACE (TbGetOwnerId); 790 791 792 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 793 if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) 794 { 795 *OwnerId = AcpiGbl_RootTableList.Tables[TableIndex].OwnerId; 796 Status = AE_OK; 797 } 798 799 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 800 return_ACPI_STATUS (Status); 801 } 802 803 804 /******************************************************************************* 805 * 806 * FUNCTION: AcpiTbIsTableLoaded 807 * 808 * PARAMETERS: TableIndex - Index into the root table 809 * 810 * RETURN: Table Loaded Flag 811 * 812 ******************************************************************************/ 813 814 BOOLEAN 815 AcpiTbIsTableLoaded ( 816 UINT32 TableIndex) 817 { 818 BOOLEAN IsLoaded = FALSE; 819 820 821 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 822 if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) 823 { 824 IsLoaded = (BOOLEAN) 825 (AcpiGbl_RootTableList.Tables[TableIndex].Flags & 826 ACPI_TABLE_IS_LOADED); 827 } 828 829 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 830 return (IsLoaded); 831 } 832 833 834 /******************************************************************************* 835 * 836 * FUNCTION: AcpiTbSetTableLoadedFlag 837 * 838 * PARAMETERS: TableIndex - Table index 839 * IsLoaded - TRUE if table is loaded, FALSE otherwise 840 * 841 * RETURN: None 842 * 843 * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE. 844 * 845 ******************************************************************************/ 846 847 void 848 AcpiTbSetTableLoadedFlag ( 849 UINT32 TableIndex, 850 BOOLEAN IsLoaded) 851 { 852 853 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 854 if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) 855 { 856 if (IsLoaded) 857 { 858 AcpiGbl_RootTableList.Tables[TableIndex].Flags |= 859 ACPI_TABLE_IS_LOADED; 860 } 861 else 862 { 863 AcpiGbl_RootTableList.Tables[TableIndex].Flags &= 864 ~ACPI_TABLE_IS_LOADED; 865 } 866 } 867 868 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 869 } 870