1 /******************************************************************************
3 * Module Name: tbdata - Table manager data structure functions
5 *****************************************************************************/
7 /******************************************************************************
11 * Some or all of this work - Copyright (c) 1999 - 2015, Intel Corp.
12 * All rights reserved.
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
37 * The above copyright and patent license is granted only if the following
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
72 * 3.4. Intel retains all right, title, and interest in and to the Original
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
80 * 4. Disclaimer and Export Compliance
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
114 *****************************************************************************/
117 #include "accommon.h"
118 #include "acnamesp.h"
119 #include "actables.h"
121 #define _COMPONENT ACPI_TABLES
122 ACPI_MODULE_NAME ("tbdata")
125 /*******************************************************************************
127 * FUNCTION: AcpiTbInitTableDescriptor
129 * PARAMETERS: TableDesc - Table descriptor
130 * Address - Physical address of the table
131 * Flags - Allocation flags of the table
132 * Table - Pointer to the table
136 * DESCRIPTION: Initialize a new table descriptor
138 ******************************************************************************/
141 AcpiTbInitTableDescriptor (
142 ACPI_TABLE_DESC
*TableDesc
,
143 ACPI_PHYSICAL_ADDRESS Address
,
145 ACPI_TABLE_HEADER
*Table
)
149 * Initialize the table descriptor. Set the pointer to NULL, since the
150 * table is not fully mapped at this time.
152 memset (TableDesc
, 0, sizeof (ACPI_TABLE_DESC
));
153 TableDesc
->Address
= Address
;
154 TableDesc
->Length
= Table
->Length
;
155 TableDesc
->Flags
= Flags
;
156 ACPI_MOVE_32_TO_32 (TableDesc
->Signature
.Ascii
, Table
->Signature
);
160 /*******************************************************************************
162 * FUNCTION: AcpiTbAcquireTable
164 * PARAMETERS: TableDesc - Table descriptor
165 * TablePtr - Where table is returned
166 * TableLength - Where table length is returned
167 * TableFlags - Where table allocation flags are returned
171 * DESCRIPTION: Acquire an ACPI table. It can be used for tables not
172 * maintained in the AcpiGbl_RootTableList.
174 ******************************************************************************/
178 ACPI_TABLE_DESC
*TableDesc
,
179 ACPI_TABLE_HEADER
**TablePtr
,
183 ACPI_TABLE_HEADER
*Table
= NULL
;
186 switch (TableDesc
->Flags
& ACPI_TABLE_ORIGIN_MASK
)
188 case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL
:
190 Table
= AcpiOsMapMemory (TableDesc
->Address
, TableDesc
->Length
);
193 case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL
:
194 case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL
:
196 Table
= ACPI_CAST_PTR (ACPI_TABLE_HEADER
,
197 ACPI_PHYSADDR_TO_PTR (TableDesc
->Address
));
205 /* Table is not valid yet */
209 return (AE_NO_MEMORY
);
212 /* Fill the return values */
215 *TableLength
= TableDesc
->Length
;
216 *TableFlags
= TableDesc
->Flags
;
221 /*******************************************************************************
223 * FUNCTION: AcpiTbReleaseTable
225 * PARAMETERS: Table - Pointer for the table
226 * TableLength - Length for the table
227 * TableFlags - Allocation flags for the table
231 * DESCRIPTION: Release a table. The inverse of AcpiTbAcquireTable().
233 ******************************************************************************/
237 ACPI_TABLE_HEADER
*Table
,
242 switch (TableFlags
& ACPI_TABLE_ORIGIN_MASK
)
244 case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL
:
246 AcpiOsUnmapMemory (Table
, TableLength
);
249 case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL
:
250 case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL
:
258 /*******************************************************************************
260 * FUNCTION: AcpiTbAcquireTempTable
262 * PARAMETERS: TableDesc - Table descriptor to be acquired
263 * Address - Address of the table
264 * Flags - Allocation flags of the table
268 * DESCRIPTION: This function validates the table header to obtain the length
269 * of a table and fills the table descriptor to make its state as
270 * "INSTALLED". Such a table descriptor is only used for verified
273 ******************************************************************************/
276 AcpiTbAcquireTempTable (
277 ACPI_TABLE_DESC
*TableDesc
,
278 ACPI_PHYSICAL_ADDRESS Address
,
281 ACPI_TABLE_HEADER
*TableHeader
;
284 switch (Flags
& ACPI_TABLE_ORIGIN_MASK
)
286 case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL
:
288 /* Get the length of the full table from the header */
290 TableHeader
= AcpiOsMapMemory (Address
, sizeof (ACPI_TABLE_HEADER
));
293 return (AE_NO_MEMORY
);
296 AcpiTbInitTableDescriptor (TableDesc
, Address
, Flags
, TableHeader
);
297 AcpiOsUnmapMemory (TableHeader
, sizeof (ACPI_TABLE_HEADER
));
300 case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL
:
301 case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL
:
303 TableHeader
= ACPI_CAST_PTR (ACPI_TABLE_HEADER
,
304 ACPI_PHYSADDR_TO_PTR (Address
));
307 return (AE_NO_MEMORY
);
310 AcpiTbInitTableDescriptor (TableDesc
, Address
, Flags
, TableHeader
);
318 /* Table is not valid yet */
320 return (AE_NO_MEMORY
);
324 /*******************************************************************************
326 * FUNCTION: AcpiTbReleaseTempTable
328 * PARAMETERS: TableDesc - Table descriptor to be released
332 * DESCRIPTION: The inverse of AcpiTbAcquireTempTable().
334 *****************************************************************************/
337 AcpiTbReleaseTempTable (
338 ACPI_TABLE_DESC
*TableDesc
)
342 * Note that the .Address is maintained by the callers of
343 * AcpiTbAcquireTempTable(), thus do not invoke AcpiTbUninstallTable()
344 * where .Address will be freed.
346 AcpiTbInvalidateTable (TableDesc
);
350 /******************************************************************************
352 * FUNCTION: AcpiTbValidateTable
354 * PARAMETERS: TableDesc - Table descriptor
358 * DESCRIPTION: This function is called to validate the table, the returned
359 * table descriptor is in "VALIDATED" state.
361 *****************************************************************************/
364 AcpiTbValidateTable (
365 ACPI_TABLE_DESC
*TableDesc
)
367 ACPI_STATUS Status
= AE_OK
;
370 ACPI_FUNCTION_TRACE (TbValidateTable
);
373 /* Validate the table if necessary */
375 if (!TableDesc
->Pointer
)
377 Status
= AcpiTbAcquireTable (TableDesc
, &TableDesc
->Pointer
,
378 &TableDesc
->Length
, &TableDesc
->Flags
);
379 if (!TableDesc
->Pointer
)
381 Status
= AE_NO_MEMORY
;
385 return_ACPI_STATUS (Status
);
389 /*******************************************************************************
391 * FUNCTION: AcpiTbInvalidateTable
393 * PARAMETERS: TableDesc - Table descriptor
397 * DESCRIPTION: Invalidate one internal ACPI table, this is the inverse of
398 * AcpiTbValidateTable().
400 ******************************************************************************/
403 AcpiTbInvalidateTable (
404 ACPI_TABLE_DESC
*TableDesc
)
407 ACPI_FUNCTION_TRACE (TbInvalidateTable
);
410 /* Table must be validated */
412 if (!TableDesc
->Pointer
)
417 AcpiTbReleaseTable (TableDesc
->Pointer
, TableDesc
->Length
,
419 TableDesc
->Pointer
= NULL
;
425 /******************************************************************************
427 * FUNCTION: AcpiTbValidateTempTable
429 * PARAMETERS: TableDesc - Table descriptor
433 * DESCRIPTION: This function is called to validate the table, the returned
434 * table descriptor is in "VALIDATED" state.
436 *****************************************************************************/
439 AcpiTbValidateTempTable (
440 ACPI_TABLE_DESC
*TableDesc
)
443 if (!TableDesc
->Pointer
&& !AcpiGbl_VerifyTableChecksum
)
446 * Only validates the header of the table.
447 * Note that Length contains the size of the mapping after invoking
448 * this work around, this value is required by
449 * AcpiTbReleaseTempTable().
450 * We can do this because in AcpiInitTableDescriptor(), the Length
451 * field of the installed descriptor is filled with the actual
452 * table length obtaining from the table header.
454 TableDesc
->Length
= sizeof (ACPI_TABLE_HEADER
);
457 return (AcpiTbValidateTable (TableDesc
));
461 /******************************************************************************
463 * FUNCTION: AcpiTbVerifyTempTable
465 * PARAMETERS: TableDesc - Table descriptor
466 * Signature - Table signature to verify
470 * DESCRIPTION: This function is called to validate and verify the table, the
471 * returned table descriptor is in "VALIDATED" state.
473 *****************************************************************************/
476 AcpiTbVerifyTempTable (
477 ACPI_TABLE_DESC
*TableDesc
,
480 ACPI_STATUS Status
= AE_OK
;
483 ACPI_FUNCTION_TRACE (TbVerifyTempTable
);
486 /* Validate the table */
488 Status
= AcpiTbValidateTempTable (TableDesc
);
489 if (ACPI_FAILURE (Status
))
491 return_ACPI_STATUS (AE_NO_MEMORY
);
494 /* If a particular signature is expected (DSDT/FACS), it must match */
497 !ACPI_COMPARE_NAME (&TableDesc
->Signature
, Signature
))
499 ACPI_BIOS_ERROR ((AE_INFO
,
500 "Invalid signature 0x%X for ACPI table, expected [%s]",
501 TableDesc
->Signature
.Integer
, Signature
));
502 Status
= AE_BAD_SIGNATURE
;
503 goto InvalidateAndExit
;
506 /* Verify the checksum */
508 if (AcpiGbl_VerifyTableChecksum
)
510 Status
= AcpiTbVerifyChecksum (TableDesc
->Pointer
, TableDesc
->Length
);
511 if (ACPI_FAILURE (Status
))
513 ACPI_EXCEPTION ((AE_INFO
, AE_NO_MEMORY
,
515 " Attempted table install failed",
516 AcpiUtValidAcpiName (TableDesc
->Signature
.Ascii
) ?
517 TableDesc
->Signature
.Ascii
: "????",
518 ACPI_FORMAT_UINT64 (TableDesc
->Address
)));
520 goto InvalidateAndExit
;
524 return_ACPI_STATUS (AE_OK
);
527 AcpiTbInvalidateTable (TableDesc
);
528 return_ACPI_STATUS (Status
);
532 /*******************************************************************************
534 * FUNCTION: AcpiTbResizeRootTableList
540 * DESCRIPTION: Expand the size of global table array
542 ******************************************************************************/
545 AcpiTbResizeRootTableList (
548 ACPI_TABLE_DESC
*Tables
;
552 ACPI_FUNCTION_TRACE (TbResizeRootTableList
);
555 /* AllowResize flag is a parameter to AcpiInitializeTables */
557 if (!(AcpiGbl_RootTableList
.Flags
& ACPI_ROOT_ALLOW_RESIZE
))
559 ACPI_ERROR ((AE_INFO
, "Resize of Root Table Array is not allowed"));
560 return_ACPI_STATUS (AE_SUPPORT
);
563 /* Increase the Table Array size */
565 if (AcpiGbl_RootTableList
.Flags
& ACPI_ROOT_ORIGIN_ALLOCATED
)
567 TableCount
= AcpiGbl_RootTableList
.MaxTableCount
;
571 TableCount
= AcpiGbl_RootTableList
.CurrentTableCount
;
574 Tables
= ACPI_ALLOCATE_ZEROED (
575 ((ACPI_SIZE
) TableCount
+ ACPI_ROOT_TABLE_SIZE_INCREMENT
) *
576 sizeof (ACPI_TABLE_DESC
));
579 ACPI_ERROR ((AE_INFO
, "Could not allocate new root table array"));
580 return_ACPI_STATUS (AE_NO_MEMORY
);
583 /* Copy and free the previous table array */
585 if (AcpiGbl_RootTableList
.Tables
)
587 memcpy (Tables
, AcpiGbl_RootTableList
.Tables
,
588 (ACPI_SIZE
) TableCount
* sizeof (ACPI_TABLE_DESC
));
590 if (AcpiGbl_RootTableList
.Flags
& ACPI_ROOT_ORIGIN_ALLOCATED
)
592 ACPI_FREE (AcpiGbl_RootTableList
.Tables
);
596 AcpiGbl_RootTableList
.Tables
= Tables
;
597 AcpiGbl_RootTableList
.MaxTableCount
=
598 TableCount
+ ACPI_ROOT_TABLE_SIZE_INCREMENT
;
599 AcpiGbl_RootTableList
.Flags
|= ACPI_ROOT_ORIGIN_ALLOCATED
;
601 return_ACPI_STATUS (AE_OK
);
605 /*******************************************************************************
607 * FUNCTION: AcpiTbGetNextTableDescriptor
609 * PARAMETERS: TableIndex - Where table index is returned
610 * TableDesc - Where table descriptor is returned
612 * RETURN: Status and table index/descriptor.
614 * DESCRIPTION: Allocate a new ACPI table entry to the global table list
616 ******************************************************************************/
619 AcpiTbGetNextTableDescriptor (
621 ACPI_TABLE_DESC
**TableDesc
)
627 /* Ensure that there is room for the table in the Root Table List */
629 if (AcpiGbl_RootTableList
.CurrentTableCount
>=
630 AcpiGbl_RootTableList
.MaxTableCount
)
632 Status
= AcpiTbResizeRootTableList();
633 if (ACPI_FAILURE (Status
))
639 i
= AcpiGbl_RootTableList
.CurrentTableCount
;
640 AcpiGbl_RootTableList
.CurrentTableCount
++;
648 *TableDesc
= &AcpiGbl_RootTableList
.Tables
[i
];
655 /*******************************************************************************
657 * FUNCTION: AcpiTbTerminate
663 * DESCRIPTION: Delete all internal ACPI tables
665 ******************************************************************************/
674 ACPI_FUNCTION_TRACE (TbTerminate
);
677 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES
);
679 /* Delete the individual tables */
681 for (i
= 0; i
< AcpiGbl_RootTableList
.CurrentTableCount
; i
++)
683 AcpiTbUninstallTable (&AcpiGbl_RootTableList
.Tables
[i
]);
687 * Delete the root table array if allocated locally. Array cannot be
688 * mapped, so we don't need to check for that flag.
690 if (AcpiGbl_RootTableList
.Flags
& ACPI_ROOT_ORIGIN_ALLOCATED
)
692 ACPI_FREE (AcpiGbl_RootTableList
.Tables
);
695 AcpiGbl_RootTableList
.Tables
= NULL
;
696 AcpiGbl_RootTableList
.Flags
= 0;
697 AcpiGbl_RootTableList
.CurrentTableCount
= 0;
699 ACPI_DEBUG_PRINT ((ACPI_DB_INFO
, "ACPI Tables freed\n"));
701 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES
);
706 /*******************************************************************************
708 * FUNCTION: AcpiTbDeleteNamespaceByOwner
710 * PARAMETERS: TableIndex - Table index
714 * DESCRIPTION: Delete all namespace objects created when this table was loaded.
716 ******************************************************************************/
719 AcpiTbDeleteNamespaceByOwner (
722 ACPI_OWNER_ID OwnerId
;
726 ACPI_FUNCTION_TRACE (TbDeleteNamespaceByOwner
);
729 Status
= AcpiUtAcquireMutex (ACPI_MTX_TABLES
);
730 if (ACPI_FAILURE (Status
))
732 return_ACPI_STATUS (Status
);
735 if (TableIndex
>= AcpiGbl_RootTableList
.CurrentTableCount
)
737 /* The table index does not exist */
739 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES
);
740 return_ACPI_STATUS (AE_NOT_EXIST
);
743 /* Get the owner ID for this table, used to delete namespace nodes */
745 OwnerId
= AcpiGbl_RootTableList
.Tables
[TableIndex
].OwnerId
;
746 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES
);
749 * Need to acquire the namespace writer lock to prevent interference
750 * with any concurrent namespace walks. The interpreter must be
751 * released during the deletion since the acquisition of the deletion
752 * lock may block, and also since the execution of a namespace walk
753 * must be allowed to use the interpreter.
755 (void) AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER
);
756 Status
= AcpiUtAcquireWriteLock (&AcpiGbl_NamespaceRwLock
);
758 AcpiNsDeleteNamespaceByOwner (OwnerId
);
759 if (ACPI_FAILURE (Status
))
761 return_ACPI_STATUS (Status
);
764 AcpiUtReleaseWriteLock (&AcpiGbl_NamespaceRwLock
);
766 Status
= AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER
);
767 return_ACPI_STATUS (Status
);
771 /*******************************************************************************
773 * FUNCTION: AcpiTbAllocateOwnerId
775 * PARAMETERS: TableIndex - Table index
779 * DESCRIPTION: Allocates OwnerId in TableDesc
781 ******************************************************************************/
784 AcpiTbAllocateOwnerId (
787 ACPI_STATUS Status
= AE_BAD_PARAMETER
;
790 ACPI_FUNCTION_TRACE (TbAllocateOwnerId
);
793 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES
);
794 if (TableIndex
< AcpiGbl_RootTableList
.CurrentTableCount
)
796 Status
= AcpiUtAllocateOwnerId (
797 &(AcpiGbl_RootTableList
.Tables
[TableIndex
].OwnerId
));
800 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES
);
801 return_ACPI_STATUS (Status
);
805 /*******************************************************************************
807 * FUNCTION: AcpiTbReleaseOwnerId
809 * PARAMETERS: TableIndex - Table index
813 * DESCRIPTION: Releases OwnerId in TableDesc
815 ******************************************************************************/
818 AcpiTbReleaseOwnerId (
821 ACPI_STATUS Status
= AE_BAD_PARAMETER
;
824 ACPI_FUNCTION_TRACE (TbReleaseOwnerId
);
827 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES
);
828 if (TableIndex
< AcpiGbl_RootTableList
.CurrentTableCount
)
830 AcpiUtReleaseOwnerId (
831 &(AcpiGbl_RootTableList
.Tables
[TableIndex
].OwnerId
));
835 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES
);
836 return_ACPI_STATUS (Status
);
840 /*******************************************************************************
842 * FUNCTION: AcpiTbGetOwnerId
844 * PARAMETERS: TableIndex - Table index
845 * OwnerId - Where the table OwnerId is returned
849 * DESCRIPTION: returns OwnerId for the ACPI table
851 ******************************************************************************/
856 ACPI_OWNER_ID
*OwnerId
)
858 ACPI_STATUS Status
= AE_BAD_PARAMETER
;
861 ACPI_FUNCTION_TRACE (TbGetOwnerId
);
864 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES
);
865 if (TableIndex
< AcpiGbl_RootTableList
.CurrentTableCount
)
867 *OwnerId
= AcpiGbl_RootTableList
.Tables
[TableIndex
].OwnerId
;
871 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES
);
872 return_ACPI_STATUS (Status
);
876 /*******************************************************************************
878 * FUNCTION: AcpiTbIsTableLoaded
880 * PARAMETERS: TableIndex - Index into the root table
882 * RETURN: Table Loaded Flag
884 ******************************************************************************/
887 AcpiTbIsTableLoaded (
890 BOOLEAN IsLoaded
= FALSE
;
893 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES
);
894 if (TableIndex
< AcpiGbl_RootTableList
.CurrentTableCount
)
897 (AcpiGbl_RootTableList
.Tables
[TableIndex
].Flags
&
898 ACPI_TABLE_IS_LOADED
);
901 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES
);
906 /*******************************************************************************
908 * FUNCTION: AcpiTbSetTableLoadedFlag
910 * PARAMETERS: TableIndex - Table index
911 * IsLoaded - TRUE if table is loaded, FALSE otherwise
915 * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE.
917 ******************************************************************************/
920 AcpiTbSetTableLoadedFlag (
925 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES
);
926 if (TableIndex
< AcpiGbl_RootTableList
.CurrentTableCount
)
930 AcpiGbl_RootTableList
.Tables
[TableIndex
].Flags
|=
931 ACPI_TABLE_IS_LOADED
;
935 AcpiGbl_RootTableList
.Tables
[TableIndex
].Flags
&=
936 ~ACPI_TABLE_IS_LOADED
;
940 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES
);