1 /****************************************************************************** 2 * 3 * Module Name: tbdata - Table manager data structure functions 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2015, 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 <contrib/dev/acpica/include/acpi.h> 45 #include <contrib/dev/acpica/include/accommon.h> 46 #include <contrib/dev/acpica/include/acnamesp.h> 47 #include <contrib/dev/acpica/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 AcpiUtValidAcpiName (TableDesc->Signature.Ascii) ? 445 TableDesc->Signature.Ascii : "????", 446 ACPI_FORMAT_UINT64 (TableDesc->Address))); 447 goto InvalidateAndExit; 448 } 449 } 450 451 return_ACPI_STATUS (AE_OK); 452 453 InvalidateAndExit: 454 AcpiTbInvalidateTable (TableDesc); 455 return_ACPI_STATUS (Status); 456 } 457 458 459 /******************************************************************************* 460 * 461 * FUNCTION: AcpiTbResizeRootTableList 462 * 463 * PARAMETERS: None 464 * 465 * RETURN: Status 466 * 467 * DESCRIPTION: Expand the size of global table array 468 * 469 ******************************************************************************/ 470 471 ACPI_STATUS 472 AcpiTbResizeRootTableList ( 473 void) 474 { 475 ACPI_TABLE_DESC *Tables; 476 UINT32 TableCount; 477 478 479 ACPI_FUNCTION_TRACE (TbResizeRootTableList); 480 481 482 /* AllowResize flag is a parameter to AcpiInitializeTables */ 483 484 if (!(AcpiGbl_RootTableList.Flags & ACPI_ROOT_ALLOW_RESIZE)) 485 { 486 ACPI_ERROR ((AE_INFO, "Resize of Root Table Array is not allowed")); 487 return_ACPI_STATUS (AE_SUPPORT); 488 } 489 490 /* Increase the Table Array size */ 491 492 if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED) 493 { 494 TableCount = AcpiGbl_RootTableList.MaxTableCount; 495 } 496 else 497 { 498 TableCount = AcpiGbl_RootTableList.CurrentTableCount; 499 } 500 501 Tables = ACPI_ALLOCATE_ZEROED ( 502 ((ACPI_SIZE) TableCount + ACPI_ROOT_TABLE_SIZE_INCREMENT) * 503 sizeof (ACPI_TABLE_DESC)); 504 if (!Tables) 505 { 506 ACPI_ERROR ((AE_INFO, "Could not allocate new root table array")); 507 return_ACPI_STATUS (AE_NO_MEMORY); 508 } 509 510 /* Copy and free the previous table array */ 511 512 if (AcpiGbl_RootTableList.Tables) 513 { 514 memcpy (Tables, AcpiGbl_RootTableList.Tables, 515 (ACPI_SIZE) TableCount * sizeof (ACPI_TABLE_DESC)); 516 517 if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED) 518 { 519 ACPI_FREE (AcpiGbl_RootTableList.Tables); 520 } 521 } 522 523 AcpiGbl_RootTableList.Tables = Tables; 524 AcpiGbl_RootTableList.MaxTableCount = 525 TableCount + ACPI_ROOT_TABLE_SIZE_INCREMENT; 526 AcpiGbl_RootTableList.Flags |= ACPI_ROOT_ORIGIN_ALLOCATED; 527 528 return_ACPI_STATUS (AE_OK); 529 } 530 531 532 /******************************************************************************* 533 * 534 * FUNCTION: AcpiTbGetNextTableDescriptor 535 * 536 * PARAMETERS: TableIndex - Where table index is returned 537 * TableDesc - Where table descriptor is returned 538 * 539 * RETURN: Status and table index/descriptor. 540 * 541 * DESCRIPTION: Allocate a new ACPI table entry to the global table list 542 * 543 ******************************************************************************/ 544 545 ACPI_STATUS 546 AcpiTbGetNextTableDescriptor ( 547 UINT32 *TableIndex, 548 ACPI_TABLE_DESC **TableDesc) 549 { 550 ACPI_STATUS Status; 551 UINT32 i; 552 553 554 /* Ensure that there is room for the table in the Root Table List */ 555 556 if (AcpiGbl_RootTableList.CurrentTableCount >= 557 AcpiGbl_RootTableList.MaxTableCount) 558 { 559 Status = AcpiTbResizeRootTableList(); 560 if (ACPI_FAILURE (Status)) 561 { 562 return (Status); 563 } 564 } 565 566 i = AcpiGbl_RootTableList.CurrentTableCount; 567 AcpiGbl_RootTableList.CurrentTableCount++; 568 569 if (TableIndex) 570 { 571 *TableIndex = i; 572 } 573 if (TableDesc) 574 { 575 *TableDesc = &AcpiGbl_RootTableList.Tables[i]; 576 } 577 578 return (AE_OK); 579 } 580 581 582 /******************************************************************************* 583 * 584 * FUNCTION: AcpiTbTerminate 585 * 586 * PARAMETERS: None 587 * 588 * RETURN: None 589 * 590 * DESCRIPTION: Delete all internal ACPI tables 591 * 592 ******************************************************************************/ 593 594 void 595 AcpiTbTerminate ( 596 void) 597 { 598 UINT32 i; 599 600 601 ACPI_FUNCTION_TRACE (TbTerminate); 602 603 604 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 605 606 /* Delete the individual tables */ 607 608 for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++) 609 { 610 AcpiTbUninstallTable (&AcpiGbl_RootTableList.Tables[i]); 611 } 612 613 /* 614 * Delete the root table array if allocated locally. Array cannot be 615 * mapped, so we don't need to check for that flag. 616 */ 617 if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED) 618 { 619 ACPI_FREE (AcpiGbl_RootTableList.Tables); 620 } 621 622 AcpiGbl_RootTableList.Tables = NULL; 623 AcpiGbl_RootTableList.Flags = 0; 624 AcpiGbl_RootTableList.CurrentTableCount = 0; 625 626 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ACPI Tables freed\n")); 627 628 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 629 return_VOID; 630 } 631 632 633 /******************************************************************************* 634 * 635 * FUNCTION: AcpiTbDeleteNamespaceByOwner 636 * 637 * PARAMETERS: TableIndex - Table index 638 * 639 * RETURN: Status 640 * 641 * DESCRIPTION: Delete all namespace objects created when this table was loaded. 642 * 643 ******************************************************************************/ 644 645 ACPI_STATUS 646 AcpiTbDeleteNamespaceByOwner ( 647 UINT32 TableIndex) 648 { 649 ACPI_OWNER_ID OwnerId; 650 ACPI_STATUS Status; 651 652 653 ACPI_FUNCTION_TRACE (TbDeleteNamespaceByOwner); 654 655 656 Status = AcpiUtAcquireMutex (ACPI_MTX_TABLES); 657 if (ACPI_FAILURE (Status)) 658 { 659 return_ACPI_STATUS (Status); 660 } 661 662 if (TableIndex >= AcpiGbl_RootTableList.CurrentTableCount) 663 { 664 /* The table index does not exist */ 665 666 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 667 return_ACPI_STATUS (AE_NOT_EXIST); 668 } 669 670 /* Get the owner ID for this table, used to delete namespace nodes */ 671 672 OwnerId = AcpiGbl_RootTableList.Tables[TableIndex].OwnerId; 673 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 674 675 /* 676 * Need to acquire the namespace writer lock to prevent interference 677 * with any concurrent namespace walks. The interpreter must be 678 * released during the deletion since the acquisition of the deletion 679 * lock may block, and also since the execution of a namespace walk 680 * must be allowed to use the interpreter. 681 */ 682 (void) AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER); 683 Status = AcpiUtAcquireWriteLock (&AcpiGbl_NamespaceRwLock); 684 685 AcpiNsDeleteNamespaceByOwner (OwnerId); 686 if (ACPI_FAILURE (Status)) 687 { 688 return_ACPI_STATUS (Status); 689 } 690 691 AcpiUtReleaseWriteLock (&AcpiGbl_NamespaceRwLock); 692 693 Status = AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER); 694 return_ACPI_STATUS (Status); 695 } 696 697 698 /******************************************************************************* 699 * 700 * FUNCTION: AcpiTbAllocateOwnerId 701 * 702 * PARAMETERS: TableIndex - Table index 703 * 704 * RETURN: Status 705 * 706 * DESCRIPTION: Allocates OwnerId in TableDesc 707 * 708 ******************************************************************************/ 709 710 ACPI_STATUS 711 AcpiTbAllocateOwnerId ( 712 UINT32 TableIndex) 713 { 714 ACPI_STATUS Status = AE_BAD_PARAMETER; 715 716 717 ACPI_FUNCTION_TRACE (TbAllocateOwnerId); 718 719 720 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 721 if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) 722 { 723 Status = AcpiUtAllocateOwnerId ( 724 &(AcpiGbl_RootTableList.Tables[TableIndex].OwnerId)); 725 } 726 727 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 728 return_ACPI_STATUS (Status); 729 } 730 731 732 /******************************************************************************* 733 * 734 * FUNCTION: AcpiTbReleaseOwnerId 735 * 736 * PARAMETERS: TableIndex - Table index 737 * 738 * RETURN: Status 739 * 740 * DESCRIPTION: Releases OwnerId in TableDesc 741 * 742 ******************************************************************************/ 743 744 ACPI_STATUS 745 AcpiTbReleaseOwnerId ( 746 UINT32 TableIndex) 747 { 748 ACPI_STATUS Status = AE_BAD_PARAMETER; 749 750 751 ACPI_FUNCTION_TRACE (TbReleaseOwnerId); 752 753 754 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 755 if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) 756 { 757 AcpiUtReleaseOwnerId ( 758 &(AcpiGbl_RootTableList.Tables[TableIndex].OwnerId)); 759 Status = AE_OK; 760 } 761 762 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 763 return_ACPI_STATUS (Status); 764 } 765 766 767 /******************************************************************************* 768 * 769 * FUNCTION: AcpiTbGetOwnerId 770 * 771 * PARAMETERS: TableIndex - Table index 772 * OwnerId - Where the table OwnerId is returned 773 * 774 * RETURN: Status 775 * 776 * DESCRIPTION: returns OwnerId for the ACPI table 777 * 778 ******************************************************************************/ 779 780 ACPI_STATUS 781 AcpiTbGetOwnerId ( 782 UINT32 TableIndex, 783 ACPI_OWNER_ID *OwnerId) 784 { 785 ACPI_STATUS Status = AE_BAD_PARAMETER; 786 787 788 ACPI_FUNCTION_TRACE (TbGetOwnerId); 789 790 791 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 792 if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) 793 { 794 *OwnerId = AcpiGbl_RootTableList.Tables[TableIndex].OwnerId; 795 Status = AE_OK; 796 } 797 798 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 799 return_ACPI_STATUS (Status); 800 } 801 802 803 /******************************************************************************* 804 * 805 * FUNCTION: AcpiTbIsTableLoaded 806 * 807 * PARAMETERS: TableIndex - Index into the root table 808 * 809 * RETURN: Table Loaded Flag 810 * 811 ******************************************************************************/ 812 813 BOOLEAN 814 AcpiTbIsTableLoaded ( 815 UINT32 TableIndex) 816 { 817 BOOLEAN IsLoaded = FALSE; 818 819 820 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 821 if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) 822 { 823 IsLoaded = (BOOLEAN) 824 (AcpiGbl_RootTableList.Tables[TableIndex].Flags & 825 ACPI_TABLE_IS_LOADED); 826 } 827 828 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 829 return (IsLoaded); 830 } 831 832 833 /******************************************************************************* 834 * 835 * FUNCTION: AcpiTbSetTableLoadedFlag 836 * 837 * PARAMETERS: TableIndex - Table index 838 * IsLoaded - TRUE if table is loaded, FALSE otherwise 839 * 840 * RETURN: None 841 * 842 * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE. 843 * 844 ******************************************************************************/ 845 846 void 847 AcpiTbSetTableLoadedFlag ( 848 UINT32 TableIndex, 849 BOOLEAN IsLoaded) 850 { 851 852 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 853 if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) 854 { 855 if (IsLoaded) 856 { 857 AcpiGbl_RootTableList.Tables[TableIndex].Flags |= 858 ACPI_TABLE_IS_LOADED; 859 } 860 else 861 { 862 AcpiGbl_RootTableList.Tables[TableIndex].Flags &= 863 ~ACPI_TABLE_IS_LOADED; 864 } 865 } 866 867 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 868 } 869