arch/all-pc/acpica/source/components/tables/tbinstal.c

   1 /******************************************************************************
   2  *
   3  * Module Name: tbinstal - ACPI table installation and removal
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, 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
  45 #define __TBINSTAL_C__
  46
  47 #include "acpi.h"
  48 #include "accommon.h"
  49 #include "acnamesp.h"
  50 #include "actables.h"
  51
  52
  53 #define _COMPONENT          ACPI_TABLES
  54         ACPI_MODULE_NAME    ("tbinstal")
  55
  56
  57 /******************************************************************************
  58  *
  59  * FUNCTION:    AcpiTbVerifyTable
  60  *
  61  * PARAMETERS:  TableDesc           - table
  62  *
  63  * RETURN:      Status
  64  *
  65  * DESCRIPTION: this function is called to verify and map table
  66  *
  67  *****************************************************************************/
  68
  69 ACPI_STATUS
  70 AcpiTbVerifyTable (
  71     ACPI_TABLE_DESC         *TableDesc)
  72 {
  73     ACPI_STATUS             Status = AE_OK;
  74
  75
  76     ACPI_FUNCTION_TRACE (TbVerifyTable);
  77
  78
  79     /* Map the table if necessary */
  80
  81     if (!TableDesc->Pointer)
  82     {
  83         if ((TableDesc->Flags & ACPI_TABLE_ORIGIN_MASK) ==
  84             ACPI_TABLE_ORIGIN_MAPPED)
  85         {
  86             TableDesc->Pointer = AcpiOsMapMemory (
  87                 TableDesc->Address, TableDesc->Length);
  88         }
  89
  90         if (!TableDesc->Pointer)
  91         {
  92             return_ACPI_STATUS (AE_NO_MEMORY);
  93         }
  94     }
  95
  96     /* Always calculate checksum, ignore bad checksum if requested */
  97
  98     Status = AcpiTbVerifyChecksum (TableDesc->Pointer, TableDesc->Length);
  99
 100     return_ACPI_STATUS (Status);
 101 }
 102
 103
 104 /*******************************************************************************
 105  *
 106  * FUNCTION:    AcpiTbAddTable
 107  *
 108  * PARAMETERS:  TableDesc           - Table descriptor
 109  *              TableIndex          - Where the table index is returned
 110  *
 111  * RETURN:      Status
 112  *
 113  * DESCRIPTION: This function is called to add an ACPI table. It is used to
 114  *              dynamically load tables via the Load and LoadTable AML
 115  *              operators.
 116  *
 117  ******************************************************************************/
 118
 119 ACPI_STATUS
 120 AcpiTbAddTable (
 121     ACPI_TABLE_DESC         *TableDesc,
 122     UINT32                  *TableIndex)
 123 {
 124     UINT32                  i;
 125     ACPI_STATUS             Status = AE_OK;
 126
 127
 128     ACPI_FUNCTION_TRACE (TbAddTable);
 129
 130
 131     if (!TableDesc->Pointer)
 132     {
 133         Status = AcpiTbVerifyTable (TableDesc);
 134         if (ACPI_FAILURE (Status) || !TableDesc->Pointer)
 135         {
 136             return_ACPI_STATUS (Status);
 137         }
 138     }
 139
 140     /*
 141      * Validate the incoming table signature.
 142      *
 143      * 1) Originally, we checked the table signature for "SSDT" or "PSDT".
 144      * 2) We added support for OEMx tables, signature "OEM".
 145      * 3) Valid tables were encountered with a null signature, so we just
 146      *    gave up on validating the signature, (05/2008).
 147      * 4) We encountered non-AML tables such as the MADT, which caused
 148      *    interpreter errors and kernel faults. So now, we once again allow
 149      *    only "SSDT", "OEMx", and now, also a null signature. (05/2011).
 150      */
 151     if ((TableDesc->Pointer->Signature[0] != 0x00) &&
 152        (!ACPI_COMPARE_NAME (TableDesc->Pointer->Signature, ACPI_SIG_SSDT)) &&
 153        (ACPI_STRNCMP (TableDesc->Pointer->Signature, "OEM", 3)))
 154     {
 155         ACPI_BIOS_ERROR ((AE_INFO,
 156             "Table has invalid signature [%4.4s] (0x%8.8X), "
 157             "must be SSDT or OEMx",
 158             AcpiUtValidAcpiName (TableDesc->Pointer->Signature) ?
 159                 TableDesc->Pointer->Signature : "????",
 160             *(UINT32 *) TableDesc->Pointer->Signature));
 161
 162         return_ACPI_STATUS (AE_BAD_SIGNATURE);
 163     }
 164
 165     (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
 166
 167     /* Check if table is already registered */
 168
 169     for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; ++i)
 170     {
 171         if (!AcpiGbl_RootTableList.Tables[i].Pointer)
 172         {
 173             Status = AcpiTbVerifyTable (&AcpiGbl_RootTableList.Tables[i]);
 174             if (ACPI_FAILURE (Status) ||
 175                 !AcpiGbl_RootTableList.Tables[i].Pointer)
 176             {
 177                 continue;
 178             }
 179         }
 180
 181         /*
 182          * Check for a table match on the entire table length,
 183          * not just the header.
 184          */
 185         if (TableDesc->Length != AcpiGbl_RootTableList.Tables[i].Length)
 186         {
 187             continue;
 188         }
 189
 190         if (ACPI_MEMCMP (TableDesc->Pointer,
 191                 AcpiGbl_RootTableList.Tables[i].Pointer,
 192                 AcpiGbl_RootTableList.Tables[i].Length))
 193         {
 194             continue;
 195         }
 196
 197         /*
 198          * Note: the current mechanism does not unregister a table if it is
 199          * dynamically unloaded. The related namespace entries are deleted,
 200          * but the table remains in the root table list.
 201          *
 202          * The assumption here is that the number of different tables that
 203          * will be loaded is actually small, and there is minimal overhead
 204          * in just keeping the table in case it is needed again.
 205          *
 206          * If this assumption changes in the future (perhaps on large
 207          * machines with many table load/unload operations), tables will
 208          * need to be unregistered when they are unloaded, and slots in the
 209          * root table list should be reused when empty.
 210          */
 211
 212         /*
 213          * Table is already registered.
 214          * We can delete the table that was passed as a parameter.
 215          */
 216         AcpiTbDeleteTable (TableDesc);
 217         *TableIndex = i;
 218
 219         if (AcpiGbl_RootTableList.Tables[i].Flags & ACPI_TABLE_IS_LOADED)
 220         {
 221             /* Table is still loaded, this is an error */
 222
 223             Status = AE_ALREADY_EXISTS;
 224             goto Release;
 225         }
 226         else
 227         {
 228             /* Table was unloaded, allow it to be reloaded */
 229
 230             TableDesc->Pointer = AcpiGbl_RootTableList.Tables[i].Pointer;
 231             TableDesc->Address = AcpiGbl_RootTableList.Tables[i].Address;
 232             Status = AE_OK;
 233             goto PrintHeader;
 234         }
 235     }
 236
 237     /*
 238      * ACPI Table Override:
 239      * Allow the host to override dynamically loaded tables.
 240      * NOTE: the table is fully mapped at this point, and the mapping will
 241      * be deleted by TbTableOverride if the table is actually overridden.
 242      */
 243     (void) AcpiTbTableOverride (TableDesc->Pointer, TableDesc);
 244
 245     /* Add the table to the global root table list */
 246
 247     Status = AcpiTbStoreTable (TableDesc->Address, TableDesc->Pointer,
 248                 TableDesc->Length, TableDesc->Flags, TableIndex);
 249     if (ACPI_FAILURE (Status))
 250     {
 251         goto Release;
 252     }
 253
 254 PrintHeader:
 255     AcpiTbPrintTableHeader (TableDesc->Address, TableDesc->Pointer);
 256
 257 Release:
 258     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 259     return_ACPI_STATUS (Status);
 260 }
 261
 262
 263 /*******************************************************************************
 264  *
 265  * FUNCTION:    AcpiTbTableOverride
 266  *
 267  * PARAMETERS:  TableHeader         - Header for the original table
 268  *              TableDesc           - Table descriptor initialized for the
 269  *                                    original table. May or may not be mapped.
 270  *
 271  * RETURN:      Pointer to the entire new table. NULL if table not overridden.
 272  *              If overridden, installs the new table within the input table
 273  *              descriptor.
 274  *
 275  * DESCRIPTION: Attempt table override by calling the OSL override functions.
 276  *              Note: If the table is overridden, then the entire new table
 277  *              is mapped and returned by this function.
 278  *
 279  ******************************************************************************/
 280
 281 ACPI_TABLE_HEADER *
 282 AcpiTbTableOverride (
 283     ACPI_TABLE_HEADER       *TableHeader,
 284     ACPI_TABLE_DESC         *TableDesc)
 285 {
 286     ACPI_STATUS             Status;
 287     ACPI_TABLE_HEADER       *NewTable = NULL;
 288     ACPI_PHYSICAL_ADDRESS   NewAddress = 0;
 289     UINT32                  NewTableLength = 0;
 290     UINT8                   NewFlags;
 291     char                    *OverrideType;
 292
 293
 294     /* (1) Attempt logical override (returns a logical address) */
 295
 296     Status = AcpiOsTableOverride (TableHeader, &NewTable);
 297     if (ACPI_SUCCESS (Status) && NewTable)
 298     {
 299         NewAddress = ACPI_PTR_TO_PHYSADDR (NewTable);
 300         NewTableLength = NewTable->Length;
 301         NewFlags = ACPI_TABLE_ORIGIN_OVERRIDE;
 302         OverrideType = "Logical";
 303         goto FinishOverride;
 304     }
 305
 306     /* (2) Attempt physical override (returns a physical address) */
 307
 308     Status = AcpiOsPhysicalTableOverride (TableHeader,
 309         &NewAddress, &NewTableLength);
 310     if (ACPI_SUCCESS (Status) && NewAddress && NewTableLength)
 311     {
 312         /* Map the entire new table */
 313
 314         NewTable = AcpiOsMapMemory (NewAddress, NewTableLength);
 315         if (!NewTable)
 316         {
 317             ACPI_EXCEPTION ((AE_INFO, AE_NO_MEMORY,
 318                 "%4.4s %p Attempted physical table override failed",
 319                 TableHeader->Signature,
 320                 ACPI_CAST_PTR (void, TableDesc->Address)));
 321             return (NULL);
 322         }
 323
 324         OverrideType = "Physical";
 325         NewFlags = ACPI_TABLE_ORIGIN_MAPPED;
 326         goto FinishOverride;
 327     }
 328
 329     return (NULL); /* There was no override */
 330
 331
 332 FinishOverride:
 333
 334     ACPI_INFO ((AE_INFO,
 335         "%4.4s %p %s table override, new table: %p",
 336         TableHeader->Signature,
 337         ACPI_CAST_PTR (void, TableDesc->Address),
 338         OverrideType, NewTable));
 339
 340     /* We can now unmap/delete the original table (if fully mapped) */
 341
 342     AcpiTbDeleteTable (TableDesc);
 343
 344     /* Setup descriptor for the new table */
 345
 346     TableDesc->Address = NewAddress;
 347     TableDesc->Pointer = NewTable;
 348     TableDesc->Length = NewTableLength;
 349     TableDesc->Flags = NewFlags;
 350
 351     return (NewTable);
 352 }
 353
 354
 355 /*******************************************************************************
 356  *
 357  * FUNCTION:    AcpiTbResizeRootTableList
 358  *
 359  * PARAMETERS:  None
 360  *
 361  * RETURN:      Status
 362  *
 363  * DESCRIPTION: Expand the size of global table array
 364  *
 365  ******************************************************************************/
 366
 367 ACPI_STATUS
 368 AcpiTbResizeRootTableList (
 369     void)
 370 {
 371     ACPI_TABLE_DESC         *Tables;
 372     UINT32                  TableCount;
 373
 374
 375     ACPI_FUNCTION_TRACE (TbResizeRootTableList);
 376
 377
 378     /* AllowResize flag is a parameter to AcpiInitializeTables */
 379
 380     if (!(AcpiGbl_RootTableList.Flags & ACPI_ROOT_ALLOW_RESIZE))
 381     {
 382         ACPI_ERROR ((AE_INFO, "Resize of Root Table Array is not allowed"));
 383         return_ACPI_STATUS (AE_SUPPORT);
 384     }
 385
 386     /* Increase the Table Array size */
 387
 388     if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED)
 389     {
 390         TableCount = AcpiGbl_RootTableList.MaxTableCount;
 391     }
 392     else
 393     {
 394         TableCount = AcpiGbl_RootTableList.CurrentTableCount;
 395     }
 396
 397     Tables = ACPI_ALLOCATE_ZEROED (
 398         ((ACPI_SIZE) TableCount + ACPI_ROOT_TABLE_SIZE_INCREMENT) *
 399         sizeof (ACPI_TABLE_DESC));
 400     if (!Tables)
 401     {
 402         ACPI_ERROR ((AE_INFO, "Could not allocate new root table array"));
 403         return_ACPI_STATUS (AE_NO_MEMORY);
 404     }
 405
 406     /* Copy and free the previous table array */
 407
 408     if (AcpiGbl_RootTableList.Tables)
 409     {
 410         ACPI_MEMCPY (Tables, AcpiGbl_RootTableList.Tables,
 411             (ACPI_SIZE) TableCount * sizeof (ACPI_TABLE_DESC));
 412
 413         if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED)
 414         {
 415             ACPI_FREE (AcpiGbl_RootTableList.Tables);
 416         }
 417     }
 418
 419     AcpiGbl_RootTableList.Tables = Tables;
 420     AcpiGbl_RootTableList.MaxTableCount =
 421         TableCount + ACPI_ROOT_TABLE_SIZE_INCREMENT;
 422     AcpiGbl_RootTableList.Flags |= ACPI_ROOT_ORIGIN_ALLOCATED;
 423
 424     return_ACPI_STATUS (AE_OK);
 425 }
 426
 427
 428 /*******************************************************************************
 429  *
 430  * FUNCTION:    AcpiTbStoreTable
 431  *
 432  * PARAMETERS:  Address             - Table address
 433  *              Table               - Table header
 434  *              Length              - Table length
 435  *              Flags               - flags
 436  *
 437  * RETURN:      Status and table index.
 438  *
 439  * DESCRIPTION: Add an ACPI table to the global table list
 440  *
 441  ******************************************************************************/
 442
 443 ACPI_STATUS
 444 AcpiTbStoreTable (
 445     ACPI_PHYSICAL_ADDRESS   Address,
 446     ACPI_TABLE_HEADER       *Table,
 447     UINT32                  Length,
 448     UINT8                   Flags,
 449     UINT32                  *TableIndex)
 450 {
 451     ACPI_STATUS             Status;
 452     ACPI_TABLE_DESC         *NewTable;
 453
 454
 455     /* Ensure that there is room for the table in the Root Table List */
 456
 457     if (AcpiGbl_RootTableList.CurrentTableCount >=
 458         AcpiGbl_RootTableList.MaxTableCount)
 459     {
 460         Status = AcpiTbResizeRootTableList();
 461         if (ACPI_FAILURE (Status))
 462         {
 463             return (Status);
 464         }
 465     }
 466
 467     NewTable = &AcpiGbl_RootTableList.Tables[AcpiGbl_RootTableList.CurrentTableCount];
 468
 469     /* Initialize added table */
 470
 471     NewTable->Address = Address;
 472     NewTable->Pointer = Table;
 473     NewTable->Length = Length;
 474     NewTable->OwnerId = 0;
 475     NewTable->Flags = Flags;
 476
 477     ACPI_MOVE_32_TO_32 (&NewTable->Signature, Table->Signature);
 478
 479     *TableIndex = AcpiGbl_RootTableList.CurrentTableCount;
 480     AcpiGbl_RootTableList.CurrentTableCount++;
 481     return (AE_OK);
 482 }
 483
 484
 485 /*******************************************************************************
 486  *
 487  * FUNCTION:    AcpiTbDeleteTable
 488  *
 489  * PARAMETERS:  TableIndex          - Table index
 490  *
 491  * RETURN:      None
 492  *
 493  * DESCRIPTION: Delete one internal ACPI table
 494  *
 495  ******************************************************************************/
 496
 497 void
 498 AcpiTbDeleteTable (
 499     ACPI_TABLE_DESC         *TableDesc)
 500 {
 501
 502     /* Table must be mapped or allocated */
 503
 504     if (!TableDesc->Pointer)
 505     {
 506         return;
 507     }
 508
 509     switch (TableDesc->Flags & ACPI_TABLE_ORIGIN_MASK)
 510     {
 511     case ACPI_TABLE_ORIGIN_MAPPED:
 512
 513         AcpiOsUnmapMemory (TableDesc->Pointer, TableDesc->Length);
 514         break;
 515
 516     case ACPI_TABLE_ORIGIN_ALLOCATED:
 517
 518         ACPI_FREE (TableDesc->Pointer);
 519         break;
 520
 521     /* Not mapped or allocated, there is nothing we can do */
 522
 523     default:
 524
 525         return;
 526     }
 527
 528     TableDesc->Pointer = NULL;
 529 }
 530
 531
 532 /*******************************************************************************
 533  *
 534  * FUNCTION:    AcpiTbTerminate
 535  *
 536  * PARAMETERS:  None
 537  *
 538  * RETURN:      None
 539  *
 540  * DESCRIPTION: Delete all internal ACPI tables
 541  *
 542  ******************************************************************************/
 543
 544 void
 545 AcpiTbTerminate (
 546     void)
 547 {
 548     UINT32                  i;
 549
 550
 551     ACPI_FUNCTION_TRACE (TbTerminate);
 552
 553
 554     (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
 555
 556     /* Delete the individual tables */
 557
 558     for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
 559     {
 560         AcpiTbDeleteTable (&AcpiGbl_RootTableList.Tables[i]);
 561     }
 562
 563     /*
 564      * Delete the root table array if allocated locally. Array cannot be
 565      * mapped, so we don't need to check for that flag.
 566      */
 567     if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED)
 568     {
 569         ACPI_FREE (AcpiGbl_RootTableList.Tables);
 570     }
 571
 572     AcpiGbl_RootTableList.Tables = NULL;
 573     AcpiGbl_RootTableList.Flags = 0;
 574     AcpiGbl_RootTableList.CurrentTableCount = 0;
 575
 576     ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ACPI Tables freed\n"));
 577     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 578
 579     return_VOID;
 580 }
 581
 582
 583 /*******************************************************************************
 584  *
 585  * FUNCTION:    AcpiTbDeleteNamespaceByOwner
 586  *
 587  * PARAMETERS:  TableIndex          - Table index
 588  *
 589  * RETURN:      Status
 590  *
 591  * DESCRIPTION: Delete all namespace objects created when this table was loaded.
 592  *
 593  ******************************************************************************/
 594
 595 ACPI_STATUS
 596 AcpiTbDeleteNamespaceByOwner (
 597     UINT32                  TableIndex)
 598 {
 599     ACPI_OWNER_ID           OwnerId;
 600     ACPI_STATUS             Status;
 601
 602
 603     ACPI_FUNCTION_TRACE (TbDeleteNamespaceByOwner);
 604
 605
 606     Status = AcpiUtAcquireMutex (ACPI_MTX_TABLES);
 607     if (ACPI_FAILURE (Status))
 608     {
 609         return_ACPI_STATUS (Status);
 610     }
 611
 612     if (TableIndex >= AcpiGbl_RootTableList.CurrentTableCount)
 613     {
 614         /* The table index does not exist */
 615
 616         (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 617         return_ACPI_STATUS (AE_NOT_EXIST);
 618     }
 619
 620     /* Get the owner ID for this table, used to delete namespace nodes */
 621
 622     OwnerId = AcpiGbl_RootTableList.Tables[TableIndex].OwnerId;
 623     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 624
 625     /*
 626      * Need to acquire the namespace writer lock to prevent interference
 627      * with any concurrent namespace walks. The interpreter must be
 628      * released during the deletion since the acquisition of the deletion
 629      * lock may block, and also since the execution of a namespace walk
 630      * must be allowed to use the interpreter.
 631      */
 632     (void) AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER);
 633     Status = AcpiUtAcquireWriteLock (&AcpiGbl_NamespaceRwLock);
 634
 635     AcpiNsDeleteNamespaceByOwner (OwnerId);
 636     if (ACPI_FAILURE (Status))
 637     {
 638         return_ACPI_STATUS (Status);
 639     }
 640
 641     AcpiUtReleaseWriteLock (&AcpiGbl_NamespaceRwLock);
 642
 643     Status = AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER);
 644     return_ACPI_STATUS (Status);
 645 }
 646
 647
 648 /*******************************************************************************
 649  *
 650  * FUNCTION:    AcpiTbAllocateOwnerId
 651  *
 652  * PARAMETERS:  TableIndex          - Table index
 653  *
 654  * RETURN:      Status
 655  *
 656  * DESCRIPTION: Allocates OwnerId in TableDesc
 657  *
 658  ******************************************************************************/
 659
 660 ACPI_STATUS
 661 AcpiTbAllocateOwnerId (
 662     UINT32                  TableIndex)
 663 {
 664     ACPI_STATUS             Status = AE_BAD_PARAMETER;
 665
 666
 667     ACPI_FUNCTION_TRACE (TbAllocateOwnerId);
 668
 669
 670     (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
 671     if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount)
 672     {
 673         Status = AcpiUtAllocateOwnerId
 674                     (&(AcpiGbl_RootTableList.Tables[TableIndex].OwnerId));
 675     }
 676
 677     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 678     return_ACPI_STATUS (Status);
 679 }
 680
 681
 682 /*******************************************************************************
 683  *
 684  * FUNCTION:    AcpiTbReleaseOwnerId
 685  *
 686  * PARAMETERS:  TableIndex          - Table index
 687  *
 688  * RETURN:      Status
 689  *
 690  * DESCRIPTION: Releases OwnerId in TableDesc
 691  *
 692  ******************************************************************************/
 693
 694 ACPI_STATUS
 695 AcpiTbReleaseOwnerId (
 696     UINT32                  TableIndex)
 697 {
 698     ACPI_STATUS             Status = AE_BAD_PARAMETER;
 699
 700
 701     ACPI_FUNCTION_TRACE (TbReleaseOwnerId);
 702
 703
 704     (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
 705     if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount)
 706     {
 707         AcpiUtReleaseOwnerId (
 708             &(AcpiGbl_RootTableList.Tables[TableIndex].OwnerId));
 709         Status = AE_OK;
 710     }
 711
 712     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 713     return_ACPI_STATUS (Status);
 714 }
 715
 716
 717 /*******************************************************************************
 718  *
 719  * FUNCTION:    AcpiTbGetOwnerId
 720  *
 721  * PARAMETERS:  TableIndex          - Table index
 722  *              OwnerId             - Where the table OwnerId is returned
 723  *
 724  * RETURN:      Status
 725  *
 726  * DESCRIPTION: returns OwnerId for the ACPI table
 727  *
 728  ******************************************************************************/
 729
 730 ACPI_STATUS
 731 AcpiTbGetOwnerId (
 732     UINT32                  TableIndex,
 733     ACPI_OWNER_ID           *OwnerId)
 734 {
 735     ACPI_STATUS             Status = AE_BAD_PARAMETER;
 736
 737
 738     ACPI_FUNCTION_TRACE (TbGetOwnerId);
 739
 740
 741     (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
 742     if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount)
 743     {
 744         *OwnerId = AcpiGbl_RootTableList.Tables[TableIndex].OwnerId;
 745         Status = AE_OK;
 746     }
 747
 748     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 749     return_ACPI_STATUS (Status);
 750 }
 751
 752
 753 /*******************************************************************************
 754  *
 755  * FUNCTION:    AcpiTbIsTableLoaded
 756  *
 757  * PARAMETERS:  TableIndex          - Table index
 758  *
 759  * RETURN:      Table Loaded Flag
 760  *
 761  ******************************************************************************/
 762
 763 BOOLEAN
 764 AcpiTbIsTableLoaded (
 765     UINT32                  TableIndex)
 766 {
 767     BOOLEAN                 IsLoaded = FALSE;
 768
 769
 770     (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
 771     if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount)
 772     {
 773         IsLoaded = (BOOLEAN)
 774             (AcpiGbl_RootTableList.Tables[TableIndex].Flags &
 775             ACPI_TABLE_IS_LOADED);
 776     }
 777
 778     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 779     return (IsLoaded);
 780 }
 781
 782
 783 /*******************************************************************************
 784  *
 785  * FUNCTION:    AcpiTbSetTableLoadedFlag
 786  *
 787  * PARAMETERS:  TableIndex          - Table index
 788  *              IsLoaded            - TRUE if table is loaded, FALSE otherwise
 789  *
 790  * RETURN:      None
 791  *
 792  * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE.
 793  *
 794  ******************************************************************************/
 795
 796 void
 797 AcpiTbSetTableLoadedFlag (
 798     UINT32                  TableIndex,
 799     BOOLEAN                 IsLoaded)
 800 {
 801
 802     (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
 803     if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount)
 804     {
 805         if (IsLoaded)
 806         {
 807             AcpiGbl_RootTableList.Tables[TableIndex].Flags |=
 808                 ACPI_TABLE_IS_LOADED;
 809         }
 810         else
 811         {
 812             AcpiGbl_RootTableList.Tables[TableIndex].Flags &=
 813                 ~ACPI_TABLE_IS_LOADED;
 814         }
 815     }
 816
 817     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
 818 }