1 /****************************************************************************** 2 * 3 * Module Name: tbdata - Table manager data structure functions 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2014, 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 #define __TBDATA_C__ 45 46 #include <contrib/dev/acpica/include/acpi.h> 47 #include <contrib/dev/acpica/include/accommon.h> 48 #include <contrib/dev/acpica/include/acnamesp.h> 49 #include <contrib/dev/acpica/include/actables.h> 50 51 #define _COMPONENT ACPI_TABLES 52 ACPI_MODULE_NAME ("tbdata") 53 54 55 /******************************************************************************* 56 * 57 * FUNCTION: AcpiTbInitTableDescriptor 58 * 59 * PARAMETERS: TableDesc - Table descriptor 60 * Address - Physical address of the table 61 * Flags - Allocation flags of the table 62 * Table - Pointer to the table 63 * 64 * RETURN: None 65 * 66 * DESCRIPTION: Initialize a new table descriptor 67 * 68 ******************************************************************************/ 69 70 void 71 AcpiTbInitTableDescriptor ( 72 ACPI_TABLE_DESC *TableDesc, 73 ACPI_PHYSICAL_ADDRESS Address, 74 UINT8 Flags, 75 ACPI_TABLE_HEADER *Table) 76 { 77 78 /* 79 * Initialize the table descriptor. Set the pointer to NULL, since the 80 * table is not fully mapped at this time. 81 */ 82 ACPI_MEMSET (TableDesc, 0, sizeof (ACPI_TABLE_DESC)); 83 TableDesc->Address = Address; 84 TableDesc->Length = Table->Length; 85 TableDesc->Flags = Flags; 86 ACPI_MOVE_32_TO_32 (TableDesc->Signature.Ascii, Table->Signature); 87 } 88 89 90 /******************************************************************************* 91 * 92 * FUNCTION: AcpiTbAcquireTable 93 * 94 * PARAMETERS: TableDesc - Table descriptor 95 * TablePtr - Where table is returned 96 * TableLength - Where table length is returned 97 * TableFlags - Where table allocation flags are returned 98 * 99 * RETURN: Status 100 * 101 * DESCRIPTION: Acquire an ACPI table. It can be used for tables not 102 * maintained in the AcpiGbl_RootTableList. 103 * 104 ******************************************************************************/ 105 106 ACPI_STATUS 107 AcpiTbAcquireTable ( 108 ACPI_TABLE_DESC *TableDesc, 109 ACPI_TABLE_HEADER **TablePtr, 110 UINT32 *TableLength, 111 UINT8 *TableFlags) 112 { 113 ACPI_TABLE_HEADER *Table = NULL; 114 115 116 switch (TableDesc->Flags & ACPI_TABLE_ORIGIN_MASK) 117 { 118 case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL: 119 120 Table = AcpiOsMapMemory (TableDesc->Address, TableDesc->Length); 121 break; 122 123 case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL: 124 case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL: 125 126 Table = ACPI_CAST_PTR (ACPI_TABLE_HEADER, TableDesc->Address); 127 break; 128 129 default: 130 131 break; 132 } 133 134 /* Table is not valid yet */ 135 136 if (!Table) 137 { 138 return (AE_NO_MEMORY); 139 } 140 141 /* Fill the return values */ 142 143 *TablePtr = Table; 144 *TableLength = TableDesc->Length; 145 *TableFlags = TableDesc->Flags; 146 return (AE_OK); 147 } 148 149 150 /******************************************************************************* 151 * 152 * FUNCTION: AcpiTbReleaseTable 153 * 154 * PARAMETERS: Table - Pointer for the table 155 * TableLength - Length for the table 156 * TableFlags - Allocation flags for the table 157 * 158 * RETURN: None 159 * 160 * DESCRIPTION: Release a table. The inverse of AcpiTbAcquireTable(). 161 * 162 ******************************************************************************/ 163 164 void 165 AcpiTbReleaseTable ( 166 ACPI_TABLE_HEADER *Table, 167 UINT32 TableLength, 168 UINT8 TableFlags) 169 { 170 171 switch (TableFlags & ACPI_TABLE_ORIGIN_MASK) 172 { 173 case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL: 174 175 AcpiOsUnmapMemory (Table, TableLength); 176 break; 177 178 case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL: 179 case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL: 180 default: 181 182 break; 183 } 184 } 185 186 187 /******************************************************************************* 188 * 189 * FUNCTION: AcpiTbAcquireTempTable 190 * 191 * PARAMETERS: TableDesc - Table descriptor to be acquired 192 * Address - Address of the table 193 * Flags - Allocation flags of the table 194 * 195 * RETURN: Status 196 * 197 * DESCRIPTION: This function validates the table header to obtain the length 198 * of a table and fills the table descriptor to make its state as 199 * "INSTALLED". Such a table descriptor is only used for verified 200 * installation. 201 * 202 ******************************************************************************/ 203 204 ACPI_STATUS 205 AcpiTbAcquireTempTable ( 206 ACPI_TABLE_DESC *TableDesc, 207 ACPI_PHYSICAL_ADDRESS Address, 208 UINT8 Flags) 209 { 210 ACPI_TABLE_HEADER *TableHeader; 211 212 213 switch (Flags & ACPI_TABLE_ORIGIN_MASK) 214 { 215 case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL: 216 217 /* Get the length of the full table from the header */ 218 219 TableHeader = AcpiOsMapMemory (Address, sizeof (ACPI_TABLE_HEADER)); 220 if (!TableHeader) 221 { 222 return (AE_NO_MEMORY); 223 } 224 225 AcpiTbInitTableDescriptor (TableDesc, Address, Flags, TableHeader); 226 AcpiOsUnmapMemory (TableHeader, sizeof (ACPI_TABLE_HEADER)); 227 return (AE_OK); 228 229 case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL: 230 case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL: 231 232 TableHeader = ACPI_CAST_PTR (ACPI_TABLE_HEADER, 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 " ACPI_PRINTF_UINT 443 " Attempted table install failed", 444 AcpiUtValidAcpiName (TableDesc->Signature.Ascii) ? 445 TableDesc->Signature.Ascii : "????", 446 ACPI_FORMAT_TO_UINT (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 ACPI_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: AcpiTbGetNextRootIndex 535 * 536 * PARAMETERS: TableIndex - Where table index is returned 537 * 538 * RETURN: Status and table index. 539 * 540 * DESCRIPTION: Allocate a new ACPI table entry to the global table list 541 * 542 ******************************************************************************/ 543 544 ACPI_STATUS 545 AcpiTbGetNextRootIndex ( 546 UINT32 *TableIndex) 547 { 548 ACPI_STATUS Status; 549 550 551 /* Ensure that there is room for the table in the Root Table List */ 552 553 if (AcpiGbl_RootTableList.CurrentTableCount >= 554 AcpiGbl_RootTableList.MaxTableCount) 555 { 556 Status = AcpiTbResizeRootTableList(); 557 if (ACPI_FAILURE (Status)) 558 { 559 return (Status); 560 } 561 } 562 563 *TableIndex = AcpiGbl_RootTableList.CurrentTableCount; 564 AcpiGbl_RootTableList.CurrentTableCount++; 565 return (AE_OK); 566 } 567 568 569 /******************************************************************************* 570 * 571 * FUNCTION: AcpiTbTerminate 572 * 573 * PARAMETERS: None 574 * 575 * RETURN: None 576 * 577 * DESCRIPTION: Delete all internal ACPI tables 578 * 579 ******************************************************************************/ 580 581 void 582 AcpiTbTerminate ( 583 void) 584 { 585 UINT32 i; 586 587 588 ACPI_FUNCTION_TRACE (TbTerminate); 589 590 591 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 592 593 /* Delete the individual tables */ 594 595 for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++) 596 { 597 AcpiTbUninstallTable (&AcpiGbl_RootTableList.Tables[i]); 598 } 599 600 /* 601 * Delete the root table array if allocated locally. Array cannot be 602 * mapped, so we don't need to check for that flag. 603 */ 604 if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED) 605 { 606 ACPI_FREE (AcpiGbl_RootTableList.Tables); 607 } 608 609 AcpiGbl_RootTableList.Tables = NULL; 610 AcpiGbl_RootTableList.Flags = 0; 611 AcpiGbl_RootTableList.CurrentTableCount = 0; 612 613 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ACPI Tables freed\n")); 614 615 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 616 return_VOID; 617 } 618 619 620 /******************************************************************************* 621 * 622 * FUNCTION: AcpiTbDeleteNamespaceByOwner 623 * 624 * PARAMETERS: TableIndex - Table index 625 * 626 * RETURN: Status 627 * 628 * DESCRIPTION: Delete all namespace objects created when this table was loaded. 629 * 630 ******************************************************************************/ 631 632 ACPI_STATUS 633 AcpiTbDeleteNamespaceByOwner ( 634 UINT32 TableIndex) 635 { 636 ACPI_OWNER_ID OwnerId; 637 ACPI_STATUS Status; 638 639 640 ACPI_FUNCTION_TRACE (TbDeleteNamespaceByOwner); 641 642 643 Status = AcpiUtAcquireMutex (ACPI_MTX_TABLES); 644 if (ACPI_FAILURE (Status)) 645 { 646 return_ACPI_STATUS (Status); 647 } 648 649 if (TableIndex >= AcpiGbl_RootTableList.CurrentTableCount) 650 { 651 /* The table index does not exist */ 652 653 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 654 return_ACPI_STATUS (AE_NOT_EXIST); 655 } 656 657 /* Get the owner ID for this table, used to delete namespace nodes */ 658 659 OwnerId = AcpiGbl_RootTableList.Tables[TableIndex].OwnerId; 660 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 661 662 /* 663 * Need to acquire the namespace writer lock to prevent interference 664 * with any concurrent namespace walks. The interpreter must be 665 * released during the deletion since the acquisition of the deletion 666 * lock may block, and also since the execution of a namespace walk 667 * must be allowed to use the interpreter. 668 */ 669 (void) AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER); 670 Status = AcpiUtAcquireWriteLock (&AcpiGbl_NamespaceRwLock); 671 672 AcpiNsDeleteNamespaceByOwner (OwnerId); 673 if (ACPI_FAILURE (Status)) 674 { 675 return_ACPI_STATUS (Status); 676 } 677 678 AcpiUtReleaseWriteLock (&AcpiGbl_NamespaceRwLock); 679 680 Status = AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER); 681 return_ACPI_STATUS (Status); 682 } 683 684 685 /******************************************************************************* 686 * 687 * FUNCTION: AcpiTbAllocateOwnerId 688 * 689 * PARAMETERS: TableIndex - Table index 690 * 691 * RETURN: Status 692 * 693 * DESCRIPTION: Allocates OwnerId in TableDesc 694 * 695 ******************************************************************************/ 696 697 ACPI_STATUS 698 AcpiTbAllocateOwnerId ( 699 UINT32 TableIndex) 700 { 701 ACPI_STATUS Status = AE_BAD_PARAMETER; 702 703 704 ACPI_FUNCTION_TRACE (TbAllocateOwnerId); 705 706 707 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 708 if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) 709 { 710 Status = AcpiUtAllocateOwnerId ( 711 &(AcpiGbl_RootTableList.Tables[TableIndex].OwnerId)); 712 } 713 714 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 715 return_ACPI_STATUS (Status); 716 } 717 718 719 /******************************************************************************* 720 * 721 * FUNCTION: AcpiTbReleaseOwnerId 722 * 723 * PARAMETERS: TableIndex - Table index 724 * 725 * RETURN: Status 726 * 727 * DESCRIPTION: Releases OwnerId in TableDesc 728 * 729 ******************************************************************************/ 730 731 ACPI_STATUS 732 AcpiTbReleaseOwnerId ( 733 UINT32 TableIndex) 734 { 735 ACPI_STATUS Status = AE_BAD_PARAMETER; 736 737 738 ACPI_FUNCTION_TRACE (TbReleaseOwnerId); 739 740 741 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 742 if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) 743 { 744 AcpiUtReleaseOwnerId ( 745 &(AcpiGbl_RootTableList.Tables[TableIndex].OwnerId)); 746 Status = AE_OK; 747 } 748 749 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 750 return_ACPI_STATUS (Status); 751 } 752 753 754 /******************************************************************************* 755 * 756 * FUNCTION: AcpiTbGetOwnerId 757 * 758 * PARAMETERS: TableIndex - Table index 759 * OwnerId - Where the table OwnerId is returned 760 * 761 * RETURN: Status 762 * 763 * DESCRIPTION: returns OwnerId for the ACPI table 764 * 765 ******************************************************************************/ 766 767 ACPI_STATUS 768 AcpiTbGetOwnerId ( 769 UINT32 TableIndex, 770 ACPI_OWNER_ID *OwnerId) 771 { 772 ACPI_STATUS Status = AE_BAD_PARAMETER; 773 774 775 ACPI_FUNCTION_TRACE (TbGetOwnerId); 776 777 778 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 779 if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) 780 { 781 *OwnerId = AcpiGbl_RootTableList.Tables[TableIndex].OwnerId; 782 Status = AE_OK; 783 } 784 785 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 786 return_ACPI_STATUS (Status); 787 } 788 789 790 /******************************************************************************* 791 * 792 * FUNCTION: AcpiTbIsTableLoaded 793 * 794 * PARAMETERS: TableIndex - Index into the root table 795 * 796 * RETURN: Table Loaded Flag 797 * 798 ******************************************************************************/ 799 800 BOOLEAN 801 AcpiTbIsTableLoaded ( 802 UINT32 TableIndex) 803 { 804 BOOLEAN IsLoaded = FALSE; 805 806 807 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 808 if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) 809 { 810 IsLoaded = (BOOLEAN) 811 (AcpiGbl_RootTableList.Tables[TableIndex].Flags & 812 ACPI_TABLE_IS_LOADED); 813 } 814 815 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 816 return (IsLoaded); 817 } 818 819 820 /******************************************************************************* 821 * 822 * FUNCTION: AcpiTbSetTableLoadedFlag 823 * 824 * PARAMETERS: TableIndex - Table index 825 * IsLoaded - TRUE if table is loaded, FALSE otherwise 826 * 827 * RETURN: None 828 * 829 * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE. 830 * 831 ******************************************************************************/ 832 833 void 834 AcpiTbSetTableLoadedFlag ( 835 UINT32 TableIndex, 836 BOOLEAN IsLoaded) 837 { 838 839 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); 840 if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) 841 { 842 if (IsLoaded) 843 { 844 AcpiGbl_RootTableList.Tables[TableIndex].Flags |= 845 ACPI_TABLE_IS_LOADED; 846 } 847 else 848 { 849 AcpiGbl_RootTableList.Tables[TableIndex].Flags &= 850 ~ACPI_TABLE_IS_LOADED; 851 } 852 } 853 854 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); 855 } 856