sys/contrib/dev/acpica/components/tables/tbdata.c

   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     ACPI_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         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:    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 }