| /drivers/devman/acpica/tables/tbfadt.c |
|---|
| 0,0 → 1,752 |
| /****************************************************************************** |
| * |
| * Module Name: tbfadt - FADT table utilities |
| * |
| *****************************************************************************/ |
| /****************************************************************************** |
| * |
| * 1. Copyright Notice |
| * |
| * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp. |
| * All rights reserved. |
| * |
| * 2. License |
| * |
| * 2.1. This is your license from Intel Corp. under its intellectual property |
| * rights. You may have additional license terms from the party that provided |
| * you this software, covering your right to use that party's intellectual |
| * property rights. |
| * |
| * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a |
| * copy of the source code appearing in this file ("Covered Code") an |
| * irrevocable, perpetual, worldwide license under Intel's copyrights in the |
| * base code distributed originally by Intel ("Original Intel Code") to copy, |
| * make derivatives, distribute, use and display any portion of the Covered |
| * Code in any form, with the right to sublicense such rights; and |
| * |
| * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent |
| * license (with the right to sublicense), under only those claims of Intel |
| * patents that are infringed by the Original Intel Code, to make, use, sell, |
| * offer to sell, and import the Covered Code and derivative works thereof |
| * solely to the minimum extent necessary to exercise the above copyright |
| * license, and in no event shall the patent license extend to any additions |
| * to or modifications of the Original Intel Code. No other license or right |
| * is granted directly or by implication, estoppel or otherwise; |
| * |
| * The above copyright and patent license is granted only if the following |
| * conditions are met: |
| * |
| * 3. Conditions |
| * |
| * 3.1. Redistribution of Source with Rights to Further Distribute Source. |
| * Redistribution of source code of any substantial portion of the Covered |
| * Code or modification with rights to further distribute source must include |
| * the above Copyright Notice, the above License, this list of Conditions, |
| * and the following Disclaimer and Export Compliance provision. In addition, |
| * Licensee must cause all Covered Code to which Licensee contributes to |
| * contain a file documenting the changes Licensee made to create that Covered |
| * Code and the date of any change. Licensee must include in that file the |
| * documentation of any changes made by any predecessor Licensee. Licensee |
| * must include a prominent statement that the modification is derived, |
| * directly or indirectly, from Original Intel Code. |
| * |
| * 3.2. Redistribution of Source with no Rights to Further Distribute Source. |
| * Redistribution of source code of any substantial portion of the Covered |
| * Code or modification without rights to further distribute source must |
| * include the following Disclaimer and Export Compliance provision in the |
| * documentation and/or other materials provided with distribution. In |
| * addition, Licensee may not authorize further sublicense of source of any |
| * portion of the Covered Code, and must include terms to the effect that the |
| * license from Licensee to its licensee is limited to the intellectual |
| * property embodied in the software Licensee provides to its licensee, and |
| * not to intellectual property embodied in modifications its licensee may |
| * make. |
| * |
| * 3.3. Redistribution of Executable. Redistribution in executable form of any |
| * substantial portion of the Covered Code or modification must reproduce the |
| * above Copyright Notice, and the following Disclaimer and Export Compliance |
| * provision in the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3.4. Intel retains all right, title, and interest in and to the Original |
| * Intel Code. |
| * |
| * 3.5. Neither the name Intel nor any other trademark owned or controlled by |
| * Intel shall be used in advertising or otherwise to promote the sale, use or |
| * other dealings in products derived from or relating to the Covered Code |
| * without prior written authorization from Intel. |
| * |
| * 4. Disclaimer and Export Compliance |
| * |
| * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED |
| * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE |
| * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, |
| * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY |
| * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY |
| * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A |
| * PARTICULAR PURPOSE. |
| * |
| * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES |
| * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR |
| * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, |
| * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY |
| * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL |
| * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS |
| * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY |
| * LIMITED REMEDY. |
| * |
| * 4.3. Licensee shall not export, either directly or indirectly, any of this |
| * software or system incorporating such software without first obtaining any |
| * required license or other approval from the U. S. Department of Commerce or |
| * any other agency or department of the United States Government. In the |
| * event Licensee exports any such software from the United States or |
| * re-exports any such software from a foreign destination, Licensee shall |
| * ensure that the distribution and export/re-export of the software is in |
| * compliance with all laws, regulations, orders, or other restrictions of the |
| * U.S. Export Administration Regulations. Licensee agrees that neither it nor |
| * any of its subsidiaries will export/re-export any technical data, process, |
| * software, or service, directly or indirectly, to any country for which the |
| * United States government or any agency thereof requires an export license, |
| * other governmental approval, or letter of assurance, without first obtaining |
| * such license, approval or letter. |
| * |
| *****************************************************************************/ |
| #define __TBFADT_C__ |
| #include "acpi.h" |
| #include "accommon.h" |
| #include "actables.h" |
| #define _COMPONENT ACPI_TABLES |
| ACPI_MODULE_NAME ("tbfadt") |
| /* Local prototypes */ |
| static inline void |
| AcpiTbInitGenericAddress ( |
| ACPI_GENERIC_ADDRESS *GenericAddress, |
| UINT8 SpaceId, |
| UINT8 ByteWidth, |
| UINT64 Address); |
| static void |
| AcpiTbConvertFadt ( |
| void); |
| static void |
| AcpiTbValidateFadt ( |
| void); |
| static void |
| AcpiTbSetupFadtRegisters ( |
| void); |
| /* Table for conversion of FADT to common internal format and FADT validation */ |
| typedef struct acpi_fadt_info |
| { |
| char *Name; |
| UINT8 Address64; |
| UINT8 Address32; |
| UINT8 Length; |
| UINT8 DefaultLength; |
| UINT8 Type; |
| } ACPI_FADT_INFO; |
| #define ACPI_FADT_REQUIRED 1 |
| #define ACPI_FADT_SEPARATE_LENGTH 2 |
| static ACPI_FADT_INFO FadtInfoTable[] = |
| { |
| {"Pm1aEventBlock", |
| ACPI_FADT_OFFSET (XPm1aEventBlock), |
| ACPI_FADT_OFFSET (Pm1aEventBlock), |
| ACPI_FADT_OFFSET (Pm1EventLength), |
| ACPI_PM1_REGISTER_WIDTH * 2, /* Enable + Status register */ |
| ACPI_FADT_REQUIRED}, |
| {"Pm1bEventBlock", |
| ACPI_FADT_OFFSET (XPm1bEventBlock), |
| ACPI_FADT_OFFSET (Pm1bEventBlock), |
| ACPI_FADT_OFFSET (Pm1EventLength), |
| ACPI_PM1_REGISTER_WIDTH * 2, /* Enable + Status register */ |
| 0}, |
| {"Pm1aControlBlock", |
| ACPI_FADT_OFFSET (XPm1aControlBlock), |
| ACPI_FADT_OFFSET (Pm1aControlBlock), |
| ACPI_FADT_OFFSET (Pm1ControlLength), |
| ACPI_PM1_REGISTER_WIDTH, |
| ACPI_FADT_REQUIRED}, |
| {"Pm1bControlBlock", |
| ACPI_FADT_OFFSET (XPm1bControlBlock), |
| ACPI_FADT_OFFSET (Pm1bControlBlock), |
| ACPI_FADT_OFFSET (Pm1ControlLength), |
| ACPI_PM1_REGISTER_WIDTH, |
| 0}, |
| {"Pm2ControlBlock", |
| ACPI_FADT_OFFSET (XPm2ControlBlock), |
| ACPI_FADT_OFFSET (Pm2ControlBlock), |
| ACPI_FADT_OFFSET (Pm2ControlLength), |
| ACPI_PM2_REGISTER_WIDTH, |
| ACPI_FADT_SEPARATE_LENGTH}, |
| {"PmTimerBlock", |
| ACPI_FADT_OFFSET (XPmTimerBlock), |
| ACPI_FADT_OFFSET (PmTimerBlock), |
| ACPI_FADT_OFFSET (PmTimerLength), |
| ACPI_PM_TIMER_WIDTH, |
| ACPI_FADT_REQUIRED}, |
| {"Gpe0Block", |
| ACPI_FADT_OFFSET (XGpe0Block), |
| ACPI_FADT_OFFSET (Gpe0Block), |
| ACPI_FADT_OFFSET (Gpe0BlockLength), |
| 0, |
| ACPI_FADT_SEPARATE_LENGTH}, |
| {"Gpe1Block", |
| ACPI_FADT_OFFSET (XGpe1Block), |
| ACPI_FADT_OFFSET (Gpe1Block), |
| ACPI_FADT_OFFSET (Gpe1BlockLength), |
| 0, |
| ACPI_FADT_SEPARATE_LENGTH} |
| }; |
| #define ACPI_FADT_INFO_ENTRIES \ |
| (sizeof (FadtInfoTable) / sizeof (ACPI_FADT_INFO)) |
| /* Table used to split Event Blocks into separate status/enable registers */ |
| typedef struct acpi_fadt_pm_info |
| { |
| ACPI_GENERIC_ADDRESS *Target; |
| UINT8 Source; |
| UINT8 RegisterNum; |
| } ACPI_FADT_PM_INFO; |
| static ACPI_FADT_PM_INFO FadtPmInfoTable[] = |
| { |
| {&AcpiGbl_XPm1aStatus, |
| ACPI_FADT_OFFSET (XPm1aEventBlock), |
| 0}, |
| {&AcpiGbl_XPm1aEnable, |
| ACPI_FADT_OFFSET (XPm1aEventBlock), |
| 1}, |
| {&AcpiGbl_XPm1bStatus, |
| ACPI_FADT_OFFSET (XPm1bEventBlock), |
| 0}, |
| {&AcpiGbl_XPm1bEnable, |
| ACPI_FADT_OFFSET (XPm1bEventBlock), |
| 1} |
| }; |
| #define ACPI_FADT_PM_INFO_ENTRIES \ |
| (sizeof (FadtPmInfoTable) / sizeof (ACPI_FADT_PM_INFO)) |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbInitGenericAddress |
| * |
| * PARAMETERS: GenericAddress - GAS struct to be initialized |
| * SpaceId - ACPI Space ID for this register |
| * ByteWidth - Width of this register, in bytes |
| * Address - Address of the register |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Initialize a Generic Address Structure (GAS) |
| * See the ACPI specification for a full description and |
| * definition of this structure. |
| * |
| ******************************************************************************/ |
| static inline void |
| AcpiTbInitGenericAddress ( |
| ACPI_GENERIC_ADDRESS *GenericAddress, |
| UINT8 SpaceId, |
| UINT8 ByteWidth, |
| UINT64 Address) |
| { |
| /* |
| * The 64-bit Address field is non-aligned in the byte packed |
| * GAS struct. |
| */ |
| ACPI_MOVE_64_TO_64 (&GenericAddress->Address, &Address); |
| /* All other fields are byte-wide */ |
| GenericAddress->SpaceId = SpaceId; |
| GenericAddress->BitWidth = (UINT8) ACPI_MUL_8 (ByteWidth); |
| GenericAddress->BitOffset = 0; |
| GenericAddress->AccessWidth = 0; /* Access width ANY */ |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbParseFadt |
| * |
| * PARAMETERS: TableIndex - Index for the FADT |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Initialize the FADT, DSDT and FACS tables |
| * (FADT contains the addresses of the DSDT and FACS) |
| * |
| ******************************************************************************/ |
| void |
| AcpiTbParseFadt ( |
| UINT32 TableIndex) |
| { |
| UINT32 Length; |
| ACPI_TABLE_HEADER *Table; |
| /* |
| * The FADT has multiple versions with different lengths, |
| * and it contains pointers to both the DSDT and FACS tables. |
| * |
| * Get a local copy of the FADT and convert it to a common format |
| * Map entire FADT, assumed to be smaller than one page. |
| */ |
| Length = AcpiGbl_RootTableList.Tables[TableIndex].Length; |
| Table = AcpiOsMapMemory ( |
| AcpiGbl_RootTableList.Tables[TableIndex].Address, Length); |
| if (!Table) |
| { |
| return; |
| } |
| /* |
| * Validate the FADT checksum before we copy the table. Ignore |
| * checksum error as we want to try to get the DSDT and FACS. |
| */ |
| (void) AcpiTbVerifyChecksum (Table, Length); |
| /* Create a local copy of the FADT in common ACPI 2.0+ format */ |
| AcpiTbCreateLocalFadt (Table, Length); |
| /* All done with the real FADT, unmap it */ |
| AcpiOsUnmapMemory (Table, Length); |
| /* Obtain the DSDT and FACS tables via their addresses within the FADT */ |
| AcpiTbInstallTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XDsdt, |
| ACPI_SIG_DSDT, ACPI_TABLE_INDEX_DSDT); |
| AcpiTbInstallTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XFacs, |
| ACPI_SIG_FACS, ACPI_TABLE_INDEX_FACS); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbCreateLocalFadt |
| * |
| * PARAMETERS: Table - Pointer to BIOS FADT |
| * Length - Length of the table |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Get a local copy of the FADT and convert it to a common format. |
| * Performs validation on some important FADT fields. |
| * |
| * NOTE: We create a local copy of the FADT regardless of the version. |
| * |
| ******************************************************************************/ |
| void |
| AcpiTbCreateLocalFadt ( |
| ACPI_TABLE_HEADER *Table, |
| UINT32 Length) |
| { |
| /* |
| * Check if the FADT is larger than the largest table that we expect |
| * (the ACPI 2.0/3.0 version). If so, truncate the table, and issue |
| * a warning. |
| */ |
| if (Length > sizeof (ACPI_TABLE_FADT)) |
| { |
| ACPI_WARNING ((AE_INFO, |
| "FADT (revision %u) is longer than ACPI 2.0 version, " |
| "truncating length %u to %u", |
| Table->Revision, Length, (UINT32) sizeof (ACPI_TABLE_FADT))); |
| } |
| /* Clear the entire local FADT */ |
| ACPI_MEMSET (&AcpiGbl_FADT, 0, sizeof (ACPI_TABLE_FADT)); |
| /* Copy the original FADT, up to sizeof (ACPI_TABLE_FADT) */ |
| ACPI_MEMCPY (&AcpiGbl_FADT, Table, |
| ACPI_MIN (Length, sizeof (ACPI_TABLE_FADT))); |
| /* Convert the local copy of the FADT to the common internal format */ |
| AcpiTbConvertFadt (); |
| /* Validate FADT values now, before we make any changes */ |
| AcpiTbValidateFadt (); |
| /* Initialize the global ACPI register structures */ |
| AcpiTbSetupFadtRegisters (); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbConvertFadt |
| * |
| * PARAMETERS: None, uses AcpiGbl_FADT |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Converts all versions of the FADT to a common internal format. |
| * Expand 32-bit addresses to 64-bit as necessary. |
| * |
| * NOTE: AcpiGbl_FADT must be of size (ACPI_TABLE_FADT), |
| * and must contain a copy of the actual FADT. |
| * |
| * Notes on 64-bit register addresses: |
| * |
| * After this FADT conversion, later ACPICA code will only use the 64-bit "X" |
| * fields of the FADT for all ACPI register addresses. |
| * |
| * The 64-bit "X" fields are optional extensions to the original 32-bit FADT |
| * V1.0 fields. Even if they are present in the FADT, they are optional and |
| * are unused if the BIOS sets them to zero. Therefore, we must copy/expand |
| * 32-bit V1.0 fields if the corresponding X field is zero. |
| * |
| * For ACPI 1.0 FADTs, all 32-bit address fields are expanded to the |
| * corresponding "X" fields in the internal FADT. |
| * |
| * For ACPI 2.0+ FADTs, all valid (non-zero) 32-bit address fields are expanded |
| * to the corresponding 64-bit X fields. For compatibility with other ACPI |
| * implementations, we ignore the 64-bit field if the 32-bit field is valid, |
| * regardless of whether the host OS is 32-bit or 64-bit. |
| * |
| ******************************************************************************/ |
| static void |
| AcpiTbConvertFadt ( |
| void) |
| { |
| ACPI_GENERIC_ADDRESS *Address64; |
| UINT32 Address32; |
| UINT32 i; |
| /* Update the local FADT table header length */ |
| AcpiGbl_FADT.Header.Length = sizeof (ACPI_TABLE_FADT); |
| /* |
| * Expand the 32-bit FACS and DSDT addresses to 64-bit as necessary. |
| * Later code will always use the X 64-bit field. |
| */ |
| if (!AcpiGbl_FADT.XFacs) |
| { |
| AcpiGbl_FADT.XFacs = (UINT64) AcpiGbl_FADT.Facs; |
| } |
| if (!AcpiGbl_FADT.XDsdt) |
| { |
| AcpiGbl_FADT.XDsdt = (UINT64) AcpiGbl_FADT.Dsdt; |
| } |
| /* |
| * For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which |
| * should be zero are indeed zero. This will workaround BIOSs that |
| * inadvertently place values in these fields. |
| * |
| * The ACPI 1.0 reserved fields that will be zeroed are the bytes located |
| * at offset 45, 55, 95, and the word located at offset 109, 110. |
| */ |
| if (AcpiGbl_FADT.Header.Revision < 3) |
| { |
| AcpiGbl_FADT.PreferredProfile = 0; |
| AcpiGbl_FADT.PstateControl = 0; |
| AcpiGbl_FADT.CstControl = 0; |
| AcpiGbl_FADT.BootFlags = 0; |
| } |
| /* |
| * Expand the ACPI 1.0 32-bit addresses to the ACPI 2.0 64-bit "X" |
| * generic address structures as necessary. Later code will always use |
| * the 64-bit address structures. |
| * |
| * March 2009: |
| * We now always use the 32-bit address if it is valid (non-null). This |
| * is not in accordance with the ACPI specification which states that |
| * the 64-bit address supersedes the 32-bit version, but we do this for |
| * compatibility with other ACPI implementations. Most notably, in the |
| * case where both the 32 and 64 versions are non-null, we use the 32-bit |
| * version. This is the only address that is guaranteed to have been |
| * tested by the BIOS manufacturer. |
| */ |
| for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) |
| { |
| Address32 = *ACPI_ADD_PTR (UINT32, |
| &AcpiGbl_FADT, FadtInfoTable[i].Address32); |
| Address64 = ACPI_ADD_PTR (ACPI_GENERIC_ADDRESS, |
| &AcpiGbl_FADT, FadtInfoTable[i].Address64); |
| /* |
| * If both 32- and 64-bit addresses are valid (non-zero), |
| * they must match. |
| */ |
| if (Address64->Address && Address32 && |
| (Address64->Address != (UINT64) Address32)) |
| { |
| ACPI_ERROR ((AE_INFO, |
| "32/64X address mismatch in %s: 0x%8.8X/0x%8.8X%8.8X, using 32", |
| FadtInfoTable[i].Name, Address32, |
| ACPI_FORMAT_UINT64 (Address64->Address))); |
| } |
| /* Always use 32-bit address if it is valid (non-null) */ |
| if (Address32) |
| { |
| /* |
| * Copy the 32-bit address to the 64-bit GAS structure. The |
| * Space ID is always I/O for 32-bit legacy address fields |
| */ |
| AcpiTbInitGenericAddress (Address64, ACPI_ADR_SPACE_SYSTEM_IO, |
| *ACPI_ADD_PTR (UINT8, &AcpiGbl_FADT, FadtInfoTable[i].Length), |
| (UINT64) Address32); |
| } |
| } |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbValidateFadt |
| * |
| * PARAMETERS: Table - Pointer to the FADT to be validated |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Validate various important fields within the FADT. If a problem |
| * is found, issue a message, but no status is returned. |
| * Used by both the table manager and the disassembler. |
| * |
| * Possible additional checks: |
| * (AcpiGbl_FADT.Pm1EventLength >= 4) |
| * (AcpiGbl_FADT.Pm1ControlLength >= 2) |
| * (AcpiGbl_FADT.PmTimerLength >= 4) |
| * Gpe block lengths must be multiple of 2 |
| * |
| ******************************************************************************/ |
| static void |
| AcpiTbValidateFadt ( |
| void) |
| { |
| char *Name; |
| ACPI_GENERIC_ADDRESS *Address64; |
| UINT8 Length; |
| UINT32 i; |
| /* |
| * Check for FACS and DSDT address mismatches. An address mismatch between |
| * the 32-bit and 64-bit address fields (FIRMWARE_CTRL/X_FIRMWARE_CTRL and |
| * DSDT/X_DSDT) would indicate the presence of two FACS or two DSDT tables. |
| */ |
| if (AcpiGbl_FADT.Facs && |
| (AcpiGbl_FADT.XFacs != (UINT64) AcpiGbl_FADT.Facs)) |
| { |
| ACPI_WARNING ((AE_INFO, |
| "32/64X FACS address mismatch in FADT - " |
| "0x%8.8X/0x%8.8X%8.8X, using 32", |
| AcpiGbl_FADT.Facs, ACPI_FORMAT_UINT64 (AcpiGbl_FADT.XFacs))); |
| AcpiGbl_FADT.XFacs = (UINT64) AcpiGbl_FADT.Facs; |
| } |
| if (AcpiGbl_FADT.Dsdt && |
| (AcpiGbl_FADT.XDsdt != (UINT64) AcpiGbl_FADT.Dsdt)) |
| { |
| ACPI_WARNING ((AE_INFO, |
| "32/64X DSDT address mismatch in FADT - " |
| "0x%8.8X/0x%8.8X%8.8X, using 32", |
| AcpiGbl_FADT.Dsdt, ACPI_FORMAT_UINT64 (AcpiGbl_FADT.XDsdt))); |
| AcpiGbl_FADT.XDsdt = (UINT64) AcpiGbl_FADT.Dsdt; |
| } |
| /* Examine all of the 64-bit extended address fields (X fields) */ |
| for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) |
| { |
| /* |
| * Generate pointer to the 64-bit address, get the register |
| * length (width) and the register name |
| */ |
| Address64 = ACPI_ADD_PTR (ACPI_GENERIC_ADDRESS, |
| &AcpiGbl_FADT, FadtInfoTable[i].Address64); |
| Length = *ACPI_ADD_PTR (UINT8, |
| &AcpiGbl_FADT, FadtInfoTable[i].Length); |
| Name = FadtInfoTable[i].Name; |
| /* |
| * For each extended field, check for length mismatch between the |
| * legacy length field and the corresponding 64-bit X length field. |
| */ |
| if (Address64->Address && |
| (Address64->BitWidth != ACPI_MUL_8 (Length))) |
| { |
| ACPI_WARNING ((AE_INFO, |
| "32/64X length mismatch in %s: %u/%u", |
| Name, ACPI_MUL_8 (Length), Address64->BitWidth)); |
| } |
| if (FadtInfoTable[i].Type & ACPI_FADT_REQUIRED) |
| { |
| /* |
| * Field is required (PM1aEvent, PM1aControl, PmTimer). |
| * Both the address and length must be non-zero. |
| */ |
| if (!Address64->Address || !Length) |
| { |
| ACPI_ERROR ((AE_INFO, |
| "Required field %s has zero address and/or length:" |
| " 0x%8.8X%8.8X/0x%X", |
| Name, ACPI_FORMAT_UINT64 (Address64->Address), Length)); |
| } |
| } |
| else if (FadtInfoTable[i].Type & ACPI_FADT_SEPARATE_LENGTH) |
| { |
| /* |
| * Field is optional (PM2Control, GPE0, GPE1) AND has its own |
| * length field. If present, both the address and length must |
| * be valid. |
| */ |
| if ((Address64->Address && !Length) || |
| (!Address64->Address && Length)) |
| { |
| ACPI_WARNING ((AE_INFO, |
| "Optional field %s has zero address or length: " |
| "0x%8.8X%8.8X/0x%X", |
| Name, ACPI_FORMAT_UINT64 (Address64->Address), Length)); |
| } |
| } |
| } |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbSetupFadtRegisters |
| * |
| * PARAMETERS: None, uses AcpiGbl_FADT. |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Initialize global ACPI PM1 register definitions. Optionally, |
| * force FADT register definitions to their default lengths. |
| * |
| ******************************************************************************/ |
| static void |
| AcpiTbSetupFadtRegisters ( |
| void) |
| { |
| ACPI_GENERIC_ADDRESS *Target64; |
| ACPI_GENERIC_ADDRESS *Source64; |
| UINT8 Pm1RegisterByteWidth; |
| UINT32 i; |
| /* |
| * Optionally check all register lengths against the default values and |
| * update them if they are incorrect. |
| */ |
| if (AcpiGbl_UseDefaultRegisterWidths) |
| { |
| for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) |
| { |
| Target64 = ACPI_ADD_PTR (ACPI_GENERIC_ADDRESS, &AcpiGbl_FADT, |
| FadtInfoTable[i].Address64); |
| /* |
| * If a valid register (Address != 0) and the (DefaultLength > 0) |
| * (Not a GPE register), then check the width against the default. |
| */ |
| if ((Target64->Address) && |
| (FadtInfoTable[i].DefaultLength > 0) && |
| (FadtInfoTable[i].DefaultLength != Target64->BitWidth)) |
| { |
| ACPI_WARNING ((AE_INFO, |
| "Invalid length for %s: %u, using default %u", |
| FadtInfoTable[i].Name, Target64->BitWidth, |
| FadtInfoTable[i].DefaultLength)); |
| /* Incorrect size, set width to the default */ |
| Target64->BitWidth = FadtInfoTable[i].DefaultLength; |
| } |
| } |
| } |
| /* |
| * Get the length of the individual PM1 registers (enable and status). |
| * Each register is defined to be (event block length / 2). Extra divide |
| * by 8 converts bits to bytes. |
| */ |
| Pm1RegisterByteWidth = (UINT8) |
| ACPI_DIV_16 (AcpiGbl_FADT.XPm1aEventBlock.BitWidth); |
| /* |
| * Calculate separate GAS structs for the PM1x (A/B) Status and Enable |
| * registers. These addresses do not appear (directly) in the FADT, so it |
| * is useful to pre-calculate them from the PM1 Event Block definitions. |
| * |
| * The PM event blocks are split into two register blocks, first is the |
| * PM Status Register block, followed immediately by the PM Enable |
| * Register block. Each is of length (Pm1EventLength/2) |
| * |
| * Note: The PM1A event block is required by the ACPI specification. |
| * However, the PM1B event block is optional and is rarely, if ever, |
| * used. |
| */ |
| for (i = 0; i < ACPI_FADT_PM_INFO_ENTRIES; i++) |
| { |
| Source64 = ACPI_ADD_PTR (ACPI_GENERIC_ADDRESS, &AcpiGbl_FADT, |
| FadtPmInfoTable[i].Source); |
| if (Source64->Address) |
| { |
| AcpiTbInitGenericAddress (FadtPmInfoTable[i].Target, |
| Source64->SpaceId, Pm1RegisterByteWidth, |
| Source64->Address + |
| (FadtPmInfoTable[i].RegisterNum * Pm1RegisterByteWidth)); |
| } |
| } |
| } |
| /drivers/devman/acpica/tables/tbfind.c |
|---|
| 0,0 → 1,215 |
| /****************************************************************************** |
| * |
| * Module Name: tbfind - find table |
| * |
| *****************************************************************************/ |
| /****************************************************************************** |
| * |
| * 1. Copyright Notice |
| * |
| * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp. |
| * All rights reserved. |
| * |
| * 2. License |
| * |
| * 2.1. This is your license from Intel Corp. under its intellectual property |
| * rights. You may have additional license terms from the party that provided |
| * you this software, covering your right to use that party's intellectual |
| * property rights. |
| * |
| * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a |
| * copy of the source code appearing in this file ("Covered Code") an |
| * irrevocable, perpetual, worldwide license under Intel's copyrights in the |
| * base code distributed originally by Intel ("Original Intel Code") to copy, |
| * make derivatives, distribute, use and display any portion of the Covered |
| * Code in any form, with the right to sublicense such rights; and |
| * |
| * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent |
| * license (with the right to sublicense), under only those claims of Intel |
| * patents that are infringed by the Original Intel Code, to make, use, sell, |
| * offer to sell, and import the Covered Code and derivative works thereof |
| * solely to the minimum extent necessary to exercise the above copyright |
| * license, and in no event shall the patent license extend to any additions |
| * to or modifications of the Original Intel Code. No other license or right |
| * is granted directly or by implication, estoppel or otherwise; |
| * |
| * The above copyright and patent license is granted only if the following |
| * conditions are met: |
| * |
| * 3. Conditions |
| * |
| * 3.1. Redistribution of Source with Rights to Further Distribute Source. |
| * Redistribution of source code of any substantial portion of the Covered |
| * Code or modification with rights to further distribute source must include |
| * the above Copyright Notice, the above License, this list of Conditions, |
| * and the following Disclaimer and Export Compliance provision. In addition, |
| * Licensee must cause all Covered Code to which Licensee contributes to |
| * contain a file documenting the changes Licensee made to create that Covered |
| * Code and the date of any change. Licensee must include in that file the |
| * documentation of any changes made by any predecessor Licensee. Licensee |
| * must include a prominent statement that the modification is derived, |
| * directly or indirectly, from Original Intel Code. |
| * |
| * 3.2. Redistribution of Source with no Rights to Further Distribute Source. |
| * Redistribution of source code of any substantial portion of the Covered |
| * Code or modification without rights to further distribute source must |
| * include the following Disclaimer and Export Compliance provision in the |
| * documentation and/or other materials provided with distribution. In |
| * addition, Licensee may not authorize further sublicense of source of any |
| * portion of the Covered Code, and must include terms to the effect that the |
| * license from Licensee to its licensee is limited to the intellectual |
| * property embodied in the software Licensee provides to its licensee, and |
| * not to intellectual property embodied in modifications its licensee may |
| * make. |
| * |
| * 3.3. Redistribution of Executable. Redistribution in executable form of any |
| * substantial portion of the Covered Code or modification must reproduce the |
| * above Copyright Notice, and the following Disclaimer and Export Compliance |
| * provision in the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3.4. Intel retains all right, title, and interest in and to the Original |
| * Intel Code. |
| * |
| * 3.5. Neither the name Intel nor any other trademark owned or controlled by |
| * Intel shall be used in advertising or otherwise to promote the sale, use or |
| * other dealings in products derived from or relating to the Covered Code |
| * without prior written authorization from Intel. |
| * |
| * 4. Disclaimer and Export Compliance |
| * |
| * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED |
| * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE |
| * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, |
| * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY |
| * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY |
| * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A |
| * PARTICULAR PURPOSE. |
| * |
| * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES |
| * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR |
| * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, |
| * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY |
| * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL |
| * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS |
| * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY |
| * LIMITED REMEDY. |
| * |
| * 4.3. Licensee shall not export, either directly or indirectly, any of this |
| * software or system incorporating such software without first obtaining any |
| * required license or other approval from the U. S. Department of Commerce or |
| * any other agency or department of the United States Government. In the |
| * event Licensee exports any such software from the United States or |
| * re-exports any such software from a foreign destination, Licensee shall |
| * ensure that the distribution and export/re-export of the software is in |
| * compliance with all laws, regulations, orders, or other restrictions of the |
| * U.S. Export Administration Regulations. Licensee agrees that neither it nor |
| * any of its subsidiaries will export/re-export any technical data, process, |
| * software, or service, directly or indirectly, to any country for which the |
| * United States government or any agency thereof requires an export license, |
| * other governmental approval, or letter of assurance, without first obtaining |
| * such license, approval or letter. |
| * |
| *****************************************************************************/ |
| #define __TBFIND_C__ |
| #include "acpi.h" |
| #include "accommon.h" |
| #include "actables.h" |
| #define _COMPONENT ACPI_TABLES |
| ACPI_MODULE_NAME ("tbfind") |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbFindTable |
| * |
| * PARAMETERS: Signature - String with ACPI table signature |
| * OemId - String with the table OEM ID |
| * OemTableId - String with the OEM Table ID |
| * TableIndex - Where the table index is returned |
| * |
| * RETURN: Status and table index |
| * |
| * DESCRIPTION: Find an ACPI table (in the RSDT/XSDT) that matches the |
| * Signature, OEM ID and OEM Table ID. Returns an index that can |
| * be used to get the table header or entire table. |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiTbFindTable ( |
| char *Signature, |
| char *OemId, |
| char *OemTableId, |
| UINT32 *TableIndex) |
| { |
| UINT32 i; |
| ACPI_STATUS Status; |
| ACPI_TABLE_HEADER Header; |
| ACPI_FUNCTION_TRACE (TbFindTable); |
| /* Normalize the input strings */ |
| ACPI_MEMSET (&Header, 0, sizeof (ACPI_TABLE_HEADER)); |
| ACPI_STRNCPY (Header.Signature, Signature, ACPI_NAME_SIZE); |
| ACPI_STRNCPY (Header.OemId, OemId, ACPI_OEM_ID_SIZE); |
| ACPI_STRNCPY (Header.OemTableId, OemTableId, ACPI_OEM_TABLE_ID_SIZE); |
| /* Search for the table */ |
| for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; ++i) |
| { |
| if (ACPI_MEMCMP (&(AcpiGbl_RootTableList.Tables[i].Signature), |
| Header.Signature, ACPI_NAME_SIZE)) |
| { |
| /* Not the requested table */ |
| continue; |
| } |
| /* Table with matching signature has been found */ |
| if (!AcpiGbl_RootTableList.Tables[i].Pointer) |
| { |
| /* Table is not currently mapped, map it */ |
| Status = AcpiTbVerifyTable (&AcpiGbl_RootTableList.Tables[i]); |
| if (ACPI_FAILURE (Status)) |
| { |
| return_ACPI_STATUS (Status); |
| } |
| if (!AcpiGbl_RootTableList.Tables[i].Pointer) |
| { |
| continue; |
| } |
| } |
| /* Check for table match on all IDs */ |
| if (!ACPI_MEMCMP (AcpiGbl_RootTableList.Tables[i].Pointer->Signature, |
| Header.Signature, ACPI_NAME_SIZE) && |
| (!OemId[0] || |
| !ACPI_MEMCMP (AcpiGbl_RootTableList.Tables[i].Pointer->OemId, |
| Header.OemId, ACPI_OEM_ID_SIZE)) && |
| (!OemTableId[0] || |
| !ACPI_MEMCMP (AcpiGbl_RootTableList.Tables[i].Pointer->OemTableId, |
| Header.OemTableId, ACPI_OEM_TABLE_ID_SIZE))) |
| { |
| *TableIndex = i; |
| ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "Found table [%4.4s]\n", |
| Header.Signature)); |
| return_ACPI_STATUS (AE_OK); |
| } |
| } |
| return_ACPI_STATUS (AE_NOT_FOUND); |
| } |
| /drivers/devman/acpica/tables/tbinstal.c |
|---|
| 0,0 → 1,787 |
| /****************************************************************************** |
| * |
| * Module Name: tbinstal - ACPI table installation and removal |
| * |
| *****************************************************************************/ |
| /****************************************************************************** |
| * |
| * 1. Copyright Notice |
| * |
| * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp. |
| * All rights reserved. |
| * |
| * 2. License |
| * |
| * 2.1. This is your license from Intel Corp. under its intellectual property |
| * rights. You may have additional license terms from the party that provided |
| * you this software, covering your right to use that party's intellectual |
| * property rights. |
| * |
| * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a |
| * copy of the source code appearing in this file ("Covered Code") an |
| * irrevocable, perpetual, worldwide license under Intel's copyrights in the |
| * base code distributed originally by Intel ("Original Intel Code") to copy, |
| * make derivatives, distribute, use and display any portion of the Covered |
| * Code in any form, with the right to sublicense such rights; and |
| * |
| * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent |
| * license (with the right to sublicense), under only those claims of Intel |
| * patents that are infringed by the Original Intel Code, to make, use, sell, |
| * offer to sell, and import the Covered Code and derivative works thereof |
| * solely to the minimum extent necessary to exercise the above copyright |
| * license, and in no event shall the patent license extend to any additions |
| * to or modifications of the Original Intel Code. No other license or right |
| * is granted directly or by implication, estoppel or otherwise; |
| * |
| * The above copyright and patent license is granted only if the following |
| * conditions are met: |
| * |
| * 3. Conditions |
| * |
| * 3.1. Redistribution of Source with Rights to Further Distribute Source. |
| * Redistribution of source code of any substantial portion of the Covered |
| * Code or modification with rights to further distribute source must include |
| * the above Copyright Notice, the above License, this list of Conditions, |
| * and the following Disclaimer and Export Compliance provision. In addition, |
| * Licensee must cause all Covered Code to which Licensee contributes to |
| * contain a file documenting the changes Licensee made to create that Covered |
| * Code and the date of any change. Licensee must include in that file the |
| * documentation of any changes made by any predecessor Licensee. Licensee |
| * must include a prominent statement that the modification is derived, |
| * directly or indirectly, from Original Intel Code. |
| * |
| * 3.2. Redistribution of Source with no Rights to Further Distribute Source. |
| * Redistribution of source code of any substantial portion of the Covered |
| * Code or modification without rights to further distribute source must |
| * include the following Disclaimer and Export Compliance provision in the |
| * documentation and/or other materials provided with distribution. In |
| * addition, Licensee may not authorize further sublicense of source of any |
| * portion of the Covered Code, and must include terms to the effect that the |
| * license from Licensee to its licensee is limited to the intellectual |
| * property embodied in the software Licensee provides to its licensee, and |
| * not to intellectual property embodied in modifications its licensee may |
| * make. |
| * |
| * 3.3. Redistribution of Executable. Redistribution in executable form of any |
| * substantial portion of the Covered Code or modification must reproduce the |
| * above Copyright Notice, and the following Disclaimer and Export Compliance |
| * provision in the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3.4. Intel retains all right, title, and interest in and to the Original |
| * Intel Code. |
| * |
| * 3.5. Neither the name Intel nor any other trademark owned or controlled by |
| * Intel shall be used in advertising or otherwise to promote the sale, use or |
| * other dealings in products derived from or relating to the Covered Code |
| * without prior written authorization from Intel. |
| * |
| * 4. Disclaimer and Export Compliance |
| * |
| * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED |
| * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE |
| * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, |
| * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY |
| * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY |
| * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A |
| * PARTICULAR PURPOSE. |
| * |
| * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES |
| * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR |
| * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, |
| * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY |
| * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL |
| * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS |
| * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY |
| * LIMITED REMEDY. |
| * |
| * 4.3. Licensee shall not export, either directly or indirectly, any of this |
| * software or system incorporating such software without first obtaining any |
| * required license or other approval from the U. S. Department of Commerce or |
| * any other agency or department of the United States Government. In the |
| * event Licensee exports any such software from the United States or |
| * re-exports any such software from a foreign destination, Licensee shall |
| * ensure that the distribution and export/re-export of the software is in |
| * compliance with all laws, regulations, orders, or other restrictions of the |
| * U.S. Export Administration Regulations. Licensee agrees that neither it nor |
| * any of its subsidiaries will export/re-export any technical data, process, |
| * software, or service, directly or indirectly, to any country for which the |
| * United States government or any agency thereof requires an export license, |
| * other governmental approval, or letter of assurance, without first obtaining |
| * such license, approval or letter. |
| * |
| *****************************************************************************/ |
| #define __TBINSTAL_C__ |
| #include "acpi.h" |
| #include "accommon.h" |
| #include "acnamesp.h" |
| #include "actables.h" |
| #define _COMPONENT ACPI_TABLES |
| ACPI_MODULE_NAME ("tbinstal") |
| /****************************************************************************** |
| * |
| * FUNCTION: AcpiTbVerifyTable |
| * |
| * PARAMETERS: TableDesc - table |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: this function is called to verify and map table |
| * |
| *****************************************************************************/ |
| ACPI_STATUS |
| AcpiTbVerifyTable ( |
| ACPI_TABLE_DESC *TableDesc) |
| { |
| ACPI_STATUS Status = AE_OK; |
| ACPI_FUNCTION_TRACE (TbVerifyTable); |
| /* Map the table if necessary */ |
| if (!TableDesc->Pointer) |
| { |
| if ((TableDesc->Flags & ACPI_TABLE_ORIGIN_MASK) == |
| ACPI_TABLE_ORIGIN_MAPPED) |
| { |
| TableDesc->Pointer = AcpiOsMapMemory ( |
| TableDesc->Address, TableDesc->Length); |
| } |
| if (!TableDesc->Pointer) |
| { |
| return_ACPI_STATUS (AE_NO_MEMORY); |
| } |
| } |
| /* FACS is the odd table, has no standard ACPI header and no checksum */ |
| if (!ACPI_COMPARE_NAME (&TableDesc->Signature, ACPI_SIG_FACS)) |
| { |
| /* Always calculate checksum, ignore bad checksum if requested */ |
| Status = AcpiTbVerifyChecksum (TableDesc->Pointer, TableDesc->Length); |
| } |
| return_ACPI_STATUS (Status); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbAddTable |
| * |
| * PARAMETERS: TableDesc - Table descriptor |
| * TableIndex - Where the table index is returned |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: This function is called to add an ACPI table. It is used to |
| * dynamically load tables via the Load and LoadTable AML |
| * operators. |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiTbAddTable ( |
| ACPI_TABLE_DESC *TableDesc, |
| UINT32 *TableIndex) |
| { |
| UINT32 i; |
| ACPI_STATUS Status = AE_OK; |
| ACPI_TABLE_HEADER *OverrideTable = NULL; |
| ACPI_FUNCTION_TRACE (TbAddTable); |
| if (!TableDesc->Pointer) |
| { |
| Status = AcpiTbVerifyTable (TableDesc); |
| if (ACPI_FAILURE (Status) || !TableDesc->Pointer) |
| { |
| return_ACPI_STATUS (Status); |
| } |
| } |
| /* |
| * Originally, we checked the table signature for "SSDT" or "PSDT" here. |
| * Next, we added support for OEMx tables, signature "OEM". |
| * Valid tables were encountered with a null signature, so we've just |
| * given up on validating the signature, since it seems to be a waste |
| * of code. The original code was removed (05/2008). |
| */ |
| (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); |
| /* Check if table is already registered */ |
| for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; ++i) |
| { |
| if (!AcpiGbl_RootTableList.Tables[i].Pointer) |
| { |
| Status = AcpiTbVerifyTable (&AcpiGbl_RootTableList.Tables[i]); |
| if (ACPI_FAILURE (Status) || |
| !AcpiGbl_RootTableList.Tables[i].Pointer) |
| { |
| continue; |
| } |
| } |
| /* |
| * Check for a table match on the entire table length, |
| * not just the header. |
| */ |
| if (TableDesc->Length != AcpiGbl_RootTableList.Tables[i].Length) |
| { |
| continue; |
| } |
| if (ACPI_MEMCMP (TableDesc->Pointer, |
| AcpiGbl_RootTableList.Tables[i].Pointer, |
| AcpiGbl_RootTableList.Tables[i].Length)) |
| { |
| continue; |
| } |
| /* |
| * Note: the current mechanism does not unregister a table if it is |
| * dynamically unloaded. The related namespace entries are deleted, |
| * but the table remains in the root table list. |
| * |
| * The assumption here is that the number of different tables that |
| * will be loaded is actually small, and there is minimal overhead |
| * in just keeping the table in case it is needed again. |
| * |
| * If this assumption changes in the future (perhaps on large |
| * machines with many table load/unload operations), tables will |
| * need to be unregistered when they are unloaded, and slots in the |
| * root table list should be reused when empty. |
| */ |
| /* |
| * Table is already registered. |
| * We can delete the table that was passed as a parameter. |
| */ |
| AcpiTbDeleteTable (TableDesc); |
| *TableIndex = i; |
| if (AcpiGbl_RootTableList.Tables[i].Flags & ACPI_TABLE_IS_LOADED) |
| { |
| /* Table is still loaded, this is an error */ |
| Status = AE_ALREADY_EXISTS; |
| goto Release; |
| } |
| else |
| { |
| /* Table was unloaded, allow it to be reloaded */ |
| TableDesc->Pointer = AcpiGbl_RootTableList.Tables[i].Pointer; |
| TableDesc->Address = AcpiGbl_RootTableList.Tables[i].Address; |
| Status = AE_OK; |
| goto PrintHeader; |
| } |
| } |
| /* |
| * ACPI Table Override: |
| * Allow the host to override dynamically loaded tables. |
| */ |
| Status = AcpiOsTableOverride (TableDesc->Pointer, &OverrideTable); |
| if (ACPI_SUCCESS (Status) && OverrideTable) |
| { |
| ACPI_INFO ((AE_INFO, |
| "%4.4s @ 0x%p Table override, replaced with:", |
| TableDesc->Pointer->Signature, |
| ACPI_CAST_PTR (void, TableDesc->Address))); |
| /* We can delete the table that was passed as a parameter */ |
| AcpiTbDeleteTable (TableDesc); |
| /* Setup descriptor for the new table */ |
| TableDesc->Address = ACPI_PTR_TO_PHYSADDR (OverrideTable); |
| TableDesc->Pointer = OverrideTable; |
| TableDesc->Length = OverrideTable->Length; |
| TableDesc->Flags = ACPI_TABLE_ORIGIN_OVERRIDE; |
| } |
| /* Add the table to the global root table list */ |
| Status = AcpiTbStoreTable (TableDesc->Address, TableDesc->Pointer, |
| TableDesc->Length, TableDesc->Flags, TableIndex); |
| if (ACPI_FAILURE (Status)) |
| { |
| goto Release; |
| } |
| PrintHeader: |
| AcpiTbPrintTableHeader (TableDesc->Address, TableDesc->Pointer); |
| Release: |
| (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); |
| return_ACPI_STATUS (Status); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbResizeRootTableList |
| * |
| * PARAMETERS: None |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Expand the size of global table array |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiTbResizeRootTableList ( |
| void) |
| { |
| ACPI_TABLE_DESC *Tables; |
| ACPI_FUNCTION_TRACE (TbResizeRootTableList); |
| /* AllowResize flag is a parameter to AcpiInitializeTables */ |
| if (!(AcpiGbl_RootTableList.Flags & ACPI_ROOT_ALLOW_RESIZE)) |
| { |
| ACPI_ERROR ((AE_INFO, "Resize of Root Table Array is not allowed")); |
| return_ACPI_STATUS (AE_SUPPORT); |
| } |
| /* Increase the Table Array size */ |
| Tables = ACPI_ALLOCATE_ZEROED ( |
| ((ACPI_SIZE) AcpiGbl_RootTableList.MaxTableCount + |
| ACPI_ROOT_TABLE_SIZE_INCREMENT) * |
| sizeof (ACPI_TABLE_DESC)); |
| if (!Tables) |
| { |
| ACPI_ERROR ((AE_INFO, "Could not allocate new root table array")); |
| return_ACPI_STATUS (AE_NO_MEMORY); |
| } |
| /* Copy and free the previous table array */ |
| if (AcpiGbl_RootTableList.Tables) |
| { |
| ACPI_MEMCPY (Tables, AcpiGbl_RootTableList.Tables, |
| (ACPI_SIZE) AcpiGbl_RootTableList.MaxTableCount * sizeof (ACPI_TABLE_DESC)); |
| if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED) |
| { |
| ACPI_FREE (AcpiGbl_RootTableList.Tables); |
| } |
| } |
| AcpiGbl_RootTableList.Tables = Tables; |
| AcpiGbl_RootTableList.MaxTableCount += ACPI_ROOT_TABLE_SIZE_INCREMENT; |
| AcpiGbl_RootTableList.Flags |= (UINT8) ACPI_ROOT_ORIGIN_ALLOCATED; |
| return_ACPI_STATUS (AE_OK); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbStoreTable |
| * |
| * PARAMETERS: Address - Table address |
| * Table - Table header |
| * Length - Table length |
| * Flags - flags |
| * |
| * RETURN: Status and table index. |
| * |
| * DESCRIPTION: Add an ACPI table to the global table list |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiTbStoreTable ( |
| ACPI_PHYSICAL_ADDRESS Address, |
| ACPI_TABLE_HEADER *Table, |
| UINT32 Length, |
| UINT8 Flags, |
| UINT32 *TableIndex) |
| { |
| ACPI_STATUS Status; |
| ACPI_TABLE_DESC *NewTable; |
| /* Ensure that there is room for the table in the Root Table List */ |
| if (AcpiGbl_RootTableList.CurrentTableCount >= |
| AcpiGbl_RootTableList.MaxTableCount) |
| { |
| Status = AcpiTbResizeRootTableList(); |
| if (ACPI_FAILURE (Status)) |
| { |
| return (Status); |
| } |
| } |
| NewTable = &AcpiGbl_RootTableList.Tables[AcpiGbl_RootTableList.CurrentTableCount]; |
| /* Initialize added table */ |
| NewTable->Address = Address; |
| NewTable->Pointer = Table; |
| NewTable->Length = Length; |
| NewTable->OwnerId = 0; |
| NewTable->Flags = Flags; |
| ACPI_MOVE_32_TO_32 (&NewTable->Signature, Table->Signature); |
| *TableIndex = AcpiGbl_RootTableList.CurrentTableCount; |
| AcpiGbl_RootTableList.CurrentTableCount++; |
| return (AE_OK); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbDeleteTable |
| * |
| * PARAMETERS: TableIndex - Table index |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Delete one internal ACPI table |
| * |
| ******************************************************************************/ |
| void |
| AcpiTbDeleteTable ( |
| ACPI_TABLE_DESC *TableDesc) |
| { |
| /* Table must be mapped or allocated */ |
| if (!TableDesc->Pointer) |
| { |
| return; |
| } |
| switch (TableDesc->Flags & ACPI_TABLE_ORIGIN_MASK) |
| { |
| case ACPI_TABLE_ORIGIN_MAPPED: |
| AcpiOsUnmapMemory (TableDesc->Pointer, TableDesc->Length); |
| break; |
| case ACPI_TABLE_ORIGIN_ALLOCATED: |
| ACPI_FREE (TableDesc->Pointer); |
| break; |
| default: |
| break; |
| } |
| TableDesc->Pointer = NULL; |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbTerminate |
| * |
| * PARAMETERS: None |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Delete all internal ACPI tables |
| * |
| ******************************************************************************/ |
| void |
| AcpiTbTerminate ( |
| void) |
| { |
| UINT32 i; |
| ACPI_FUNCTION_TRACE (TbTerminate); |
| (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); |
| /* Delete the individual tables */ |
| for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++) |
| { |
| AcpiTbDeleteTable (&AcpiGbl_RootTableList.Tables[i]); |
| } |
| /* |
| * Delete the root table array if allocated locally. Array cannot be |
| * mapped, so we don't need to check for that flag. |
| */ |
| if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED) |
| { |
| ACPI_FREE (AcpiGbl_RootTableList.Tables); |
| } |
| AcpiGbl_RootTableList.Tables = NULL; |
| AcpiGbl_RootTableList.Flags = 0; |
| AcpiGbl_RootTableList.CurrentTableCount = 0; |
| ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ACPI Tables freed\n")); |
| (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbDeleteNamespaceByOwner |
| * |
| * PARAMETERS: TableIndex - Table index |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Delete all namespace objects created when this table was loaded. |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiTbDeleteNamespaceByOwner ( |
| UINT32 TableIndex) |
| { |
| ACPI_OWNER_ID OwnerId; |
| ACPI_STATUS Status; |
| ACPI_FUNCTION_TRACE (TbDeleteNamespaceByOwner); |
| Status = AcpiUtAcquireMutex (ACPI_MTX_TABLES); |
| if (ACPI_FAILURE (Status)) |
| { |
| return_ACPI_STATUS (Status); |
| } |
| if (TableIndex >= AcpiGbl_RootTableList.CurrentTableCount) |
| { |
| /* The table index does not exist */ |
| (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); |
| return_ACPI_STATUS (AE_NOT_EXIST); |
| } |
| /* Get the owner ID for this table, used to delete namespace nodes */ |
| OwnerId = AcpiGbl_RootTableList.Tables[TableIndex].OwnerId; |
| (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); |
| /* |
| * Need to acquire the namespace writer lock to prevent interference |
| * with any concurrent namespace walks. The interpreter must be |
| * released during the deletion since the acquisition of the deletion |
| * lock may block, and also since the execution of a namespace walk |
| * must be allowed to use the interpreter. |
| */ |
| (void) AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER); |
| Status = AcpiUtAcquireWriteLock (&AcpiGbl_NamespaceRwLock); |
| AcpiNsDeleteNamespaceByOwner (OwnerId); |
| if (ACPI_FAILURE (Status)) |
| { |
| return_ACPI_STATUS (Status); |
| } |
| AcpiUtReleaseWriteLock (&AcpiGbl_NamespaceRwLock); |
| Status = AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER); |
| return_ACPI_STATUS (Status); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbAllocateOwnerId |
| * |
| * PARAMETERS: TableIndex - Table index |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Allocates OwnerId in TableDesc |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiTbAllocateOwnerId ( |
| UINT32 TableIndex) |
| { |
| ACPI_STATUS Status = AE_BAD_PARAMETER; |
| ACPI_FUNCTION_TRACE (TbAllocateOwnerId); |
| (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); |
| if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) |
| { |
| Status = AcpiUtAllocateOwnerId |
| (&(AcpiGbl_RootTableList.Tables[TableIndex].OwnerId)); |
| } |
| (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); |
| return_ACPI_STATUS (Status); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbReleaseOwnerId |
| * |
| * PARAMETERS: TableIndex - Table index |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Releases OwnerId in TableDesc |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiTbReleaseOwnerId ( |
| UINT32 TableIndex) |
| { |
| ACPI_STATUS Status = AE_BAD_PARAMETER; |
| ACPI_FUNCTION_TRACE (TbReleaseOwnerId); |
| (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); |
| if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) |
| { |
| AcpiUtReleaseOwnerId ( |
| &(AcpiGbl_RootTableList.Tables[TableIndex].OwnerId)); |
| Status = AE_OK; |
| } |
| (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); |
| return_ACPI_STATUS (Status); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbGetOwnerId |
| * |
| * PARAMETERS: TableIndex - Table index |
| * OwnerId - Where the table OwnerId is returned |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: returns OwnerId for the ACPI table |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiTbGetOwnerId ( |
| UINT32 TableIndex, |
| ACPI_OWNER_ID *OwnerId) |
| { |
| ACPI_STATUS Status = AE_BAD_PARAMETER; |
| ACPI_FUNCTION_TRACE (TbGetOwnerId); |
| (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); |
| if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) |
| { |
| *OwnerId = AcpiGbl_RootTableList.Tables[TableIndex].OwnerId; |
| Status = AE_OK; |
| } |
| (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); |
| return_ACPI_STATUS (Status); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbIsTableLoaded |
| * |
| * PARAMETERS: TableIndex - Table index |
| * |
| * RETURN: Table Loaded Flag |
| * |
| ******************************************************************************/ |
| BOOLEAN |
| AcpiTbIsTableLoaded ( |
| UINT32 TableIndex) |
| { |
| BOOLEAN IsLoaded = FALSE; |
| (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); |
| if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) |
| { |
| IsLoaded = (BOOLEAN) |
| (AcpiGbl_RootTableList.Tables[TableIndex].Flags & |
| ACPI_TABLE_IS_LOADED); |
| } |
| (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); |
| return (IsLoaded); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbSetTableLoadedFlag |
| * |
| * PARAMETERS: TableIndex - Table index |
| * IsLoaded - TRUE if table is loaded, FALSE otherwise |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE. |
| * |
| ******************************************************************************/ |
| void |
| AcpiTbSetTableLoadedFlag ( |
| UINT32 TableIndex, |
| BOOLEAN IsLoaded) |
| { |
| (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); |
| if (TableIndex < AcpiGbl_RootTableList.CurrentTableCount) |
| { |
| if (IsLoaded) |
| { |
| AcpiGbl_RootTableList.Tables[TableIndex].Flags |= |
| ACPI_TABLE_IS_LOADED; |
| } |
| else |
| { |
| AcpiGbl_RootTableList.Tables[TableIndex].Flags &= |
| ~ACPI_TABLE_IS_LOADED; |
| } |
| } |
| (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); |
| } |
| /drivers/devman/acpica/tables/tbutils.c |
|---|
| 0,0 → 1,824 |
| /****************************************************************************** |
| * |
| * Module Name: tbutils - table utilities |
| * |
| *****************************************************************************/ |
| /****************************************************************************** |
| * |
| * 1. Copyright Notice |
| * |
| * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp. |
| * All rights reserved. |
| * |
| * 2. License |
| * |
| * 2.1. This is your license from Intel Corp. under its intellectual property |
| * rights. You may have additional license terms from the party that provided |
| * you this software, covering your right to use that party's intellectual |
| * property rights. |
| * |
| * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a |
| * copy of the source code appearing in this file ("Covered Code") an |
| * irrevocable, perpetual, worldwide license under Intel's copyrights in the |
| * base code distributed originally by Intel ("Original Intel Code") to copy, |
| * make derivatives, distribute, use and display any portion of the Covered |
| * Code in any form, with the right to sublicense such rights; and |
| * |
| * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent |
| * license (with the right to sublicense), under only those claims of Intel |
| * patents that are infringed by the Original Intel Code, to make, use, sell, |
| * offer to sell, and import the Covered Code and derivative works thereof |
| * solely to the minimum extent necessary to exercise the above copyright |
| * license, and in no event shall the patent license extend to any additions |
| * to or modifications of the Original Intel Code. No other license or right |
| * is granted directly or by implication, estoppel or otherwise; |
| * |
| * The above copyright and patent license is granted only if the following |
| * conditions are met: |
| * |
| * 3. Conditions |
| * |
| * 3.1. Redistribution of Source with Rights to Further Distribute Source. |
| * Redistribution of source code of any substantial portion of the Covered |
| * Code or modification with rights to further distribute source must include |
| * the above Copyright Notice, the above License, this list of Conditions, |
| * and the following Disclaimer and Export Compliance provision. In addition, |
| * Licensee must cause all Covered Code to which Licensee contributes to |
| * contain a file documenting the changes Licensee made to create that Covered |
| * Code and the date of any change. Licensee must include in that file the |
| * documentation of any changes made by any predecessor Licensee. Licensee |
| * must include a prominent statement that the modification is derived, |
| * directly or indirectly, from Original Intel Code. |
| * |
| * 3.2. Redistribution of Source with no Rights to Further Distribute Source. |
| * Redistribution of source code of any substantial portion of the Covered |
| * Code or modification without rights to further distribute source must |
| * include the following Disclaimer and Export Compliance provision in the |
| * documentation and/or other materials provided with distribution. In |
| * addition, Licensee may not authorize further sublicense of source of any |
| * portion of the Covered Code, and must include terms to the effect that the |
| * license from Licensee to its licensee is limited to the intellectual |
| * property embodied in the software Licensee provides to its licensee, and |
| * not to intellectual property embodied in modifications its licensee may |
| * make. |
| * |
| * 3.3. Redistribution of Executable. Redistribution in executable form of any |
| * substantial portion of the Covered Code or modification must reproduce the |
| * above Copyright Notice, and the following Disclaimer and Export Compliance |
| * provision in the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3.4. Intel retains all right, title, and interest in and to the Original |
| * Intel Code. |
| * |
| * 3.5. Neither the name Intel nor any other trademark owned or controlled by |
| * Intel shall be used in advertising or otherwise to promote the sale, use or |
| * other dealings in products derived from or relating to the Covered Code |
| * without prior written authorization from Intel. |
| * |
| * 4. Disclaimer and Export Compliance |
| * |
| * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED |
| * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE |
| * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, |
| * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY |
| * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY |
| * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A |
| * PARTICULAR PURPOSE. |
| * |
| * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES |
| * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR |
| * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, |
| * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY |
| * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL |
| * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS |
| * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY |
| * LIMITED REMEDY. |
| * |
| * 4.3. Licensee shall not export, either directly or indirectly, any of this |
| * software or system incorporating such software without first obtaining any |
| * required license or other approval from the U. S. Department of Commerce or |
| * any other agency or department of the United States Government. In the |
| * event Licensee exports any such software from the United States or |
| * re-exports any such software from a foreign destination, Licensee shall |
| * ensure that the distribution and export/re-export of the software is in |
| * compliance with all laws, regulations, orders, or other restrictions of the |
| * U.S. Export Administration Regulations. Licensee agrees that neither it nor |
| * any of its subsidiaries will export/re-export any technical data, process, |
| * software, or service, directly or indirectly, to any country for which the |
| * United States government or any agency thereof requires an export license, |
| * other governmental approval, or letter of assurance, without first obtaining |
| * such license, approval or letter. |
| * |
| *****************************************************************************/ |
| #define __TBUTILS_C__ |
| #include "acpi.h" |
| #include "accommon.h" |
| #include "actables.h" |
| #define _COMPONENT ACPI_TABLES |
| ACPI_MODULE_NAME ("tbutils") |
| /* Local prototypes */ |
| static void |
| AcpiTbFixString ( |
| char *String, |
| ACPI_SIZE Length); |
| static void |
| AcpiTbCleanupTableHeader ( |
| ACPI_TABLE_HEADER *OutHeader, |
| ACPI_TABLE_HEADER *Header); |
| static ACPI_PHYSICAL_ADDRESS |
| AcpiTbGetRootTableEntry ( |
| UINT8 *TableEntry, |
| UINT32 TableEntrySize); |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbInitializeFacs |
| * |
| * PARAMETERS: None |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Create a permanent mapping for the FADT and save it in a global |
| * for accessing the Global Lock and Firmware Waking Vector |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiTbInitializeFacs ( |
| void) |
| { |
| ACPI_STATUS Status; |
| Status = AcpiGetTableByIndex (ACPI_TABLE_INDEX_FACS, |
| ACPI_CAST_INDIRECT_PTR (ACPI_TABLE_HEADER, &AcpiGbl_FACS)); |
| return (Status); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbTablesLoaded |
| * |
| * PARAMETERS: None |
| * |
| * RETURN: TRUE if required ACPI tables are loaded |
| * |
| * DESCRIPTION: Determine if the minimum required ACPI tables are present |
| * (FADT, FACS, DSDT) |
| * |
| ******************************************************************************/ |
| BOOLEAN |
| AcpiTbTablesLoaded ( |
| void) |
| { |
| if (AcpiGbl_RootTableList.CurrentTableCount >= 3) |
| { |
| return (TRUE); |
| } |
| return (FALSE); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbFixString |
| * |
| * PARAMETERS: String - String to be repaired |
| * Length - Maximum length |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Replace every non-printable or non-ascii byte in the string |
| * with a question mark '?'. |
| * |
| ******************************************************************************/ |
| static void |
| AcpiTbFixString ( |
| char *String, |
| ACPI_SIZE Length) |
| { |
| while (Length && *String) |
| { |
| if (!ACPI_IS_PRINT (*String)) |
| { |
| *String = '?'; |
| } |
| String++; |
| Length--; |
| } |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbCleanupTableHeader |
| * |
| * PARAMETERS: OutHeader - Where the cleaned header is returned |
| * Header - Input ACPI table header |
| * |
| * RETURN: Returns the cleaned header in OutHeader |
| * |
| * DESCRIPTION: Copy the table header and ensure that all "string" fields in |
| * the header consist of printable characters. |
| * |
| ******************************************************************************/ |
| static void |
| AcpiTbCleanupTableHeader ( |
| ACPI_TABLE_HEADER *OutHeader, |
| ACPI_TABLE_HEADER *Header) |
| { |
| ACPI_MEMCPY (OutHeader, Header, sizeof (ACPI_TABLE_HEADER)); |
| AcpiTbFixString (OutHeader->Signature, ACPI_NAME_SIZE); |
| AcpiTbFixString (OutHeader->OemId, ACPI_OEM_ID_SIZE); |
| AcpiTbFixString (OutHeader->OemTableId, ACPI_OEM_TABLE_ID_SIZE); |
| AcpiTbFixString (OutHeader->AslCompilerId, ACPI_NAME_SIZE); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbPrintTableHeader |
| * |
| * PARAMETERS: Address - Table physical address |
| * Header - Table header |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Print an ACPI table header. Special cases for FACS and RSDP. |
| * |
| ******************************************************************************/ |
| void |
| AcpiTbPrintTableHeader ( |
| ACPI_PHYSICAL_ADDRESS Address, |
| ACPI_TABLE_HEADER *Header) |
| { |
| ACPI_TABLE_HEADER LocalHeader; |
| /* |
| * The reason that the Address is cast to a void pointer is so that we |
| * can use %p which will work properly on both 32-bit and 64-bit hosts. |
| */ |
| if (ACPI_COMPARE_NAME (Header->Signature, ACPI_SIG_FACS)) |
| { |
| /* FACS only has signature and length fields */ |
| ACPI_INFO ((AE_INFO, "%4.4s %p %05X", |
| Header->Signature, ACPI_CAST_PTR (void, Address), |
| Header->Length)); |
| } |
| else if (ACPI_COMPARE_NAME (Header->Signature, ACPI_SIG_RSDP)) |
| { |
| /* RSDP has no common fields */ |
| ACPI_MEMCPY (LocalHeader.OemId, |
| ACPI_CAST_PTR (ACPI_TABLE_RSDP, Header)->OemId, ACPI_OEM_ID_SIZE); |
| AcpiTbFixString (LocalHeader.OemId, ACPI_OEM_ID_SIZE); |
| ACPI_INFO ((AE_INFO, "RSDP %p %05X (v%.2d %6.6s)", |
| ACPI_CAST_PTR (void, Address), |
| (ACPI_CAST_PTR (ACPI_TABLE_RSDP, Header)->Revision > 0) ? |
| ACPI_CAST_PTR (ACPI_TABLE_RSDP, Header)->Length : 20, |
| ACPI_CAST_PTR (ACPI_TABLE_RSDP, Header)->Revision, |
| LocalHeader.OemId)); |
| } |
| else |
| { |
| /* Standard ACPI table with full common header */ |
| AcpiTbCleanupTableHeader (&LocalHeader, Header); |
| ACPI_INFO ((AE_INFO, |
| "%4.4s %p %05X (v%.2d %6.6s %8.8s %08X %4.4s %08X)", |
| LocalHeader.Signature, ACPI_CAST_PTR (void, Address), |
| LocalHeader.Length, LocalHeader.Revision, LocalHeader.OemId, |
| LocalHeader.OemTableId, LocalHeader.OemRevision, |
| LocalHeader.AslCompilerId, LocalHeader.AslCompilerRevision)); |
| } |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbValidateChecksum |
| * |
| * PARAMETERS: Table - ACPI table to verify |
| * Length - Length of entire table |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Verifies that the table checksums to zero. Optionally returns |
| * exception on bad checksum. |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiTbVerifyChecksum ( |
| ACPI_TABLE_HEADER *Table, |
| UINT32 Length) |
| { |
| UINT8 Checksum; |
| /* Compute the checksum on the table */ |
| Checksum = AcpiTbChecksum (ACPI_CAST_PTR (UINT8, Table), Length); |
| /* Checksum ok? (should be zero) */ |
| if (Checksum) |
| { |
| ACPI_WARNING ((AE_INFO, |
| "Incorrect checksum in table [%4.4s] - 0x%2.2X, should be 0x%2.2X", |
| Table->Signature, Table->Checksum, |
| (UINT8) (Table->Checksum - Checksum))); |
| #if (ACPI_CHECKSUM_ABORT) |
| return (AE_BAD_CHECKSUM); |
| #endif |
| } |
| return (AE_OK); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbChecksum |
| * |
| * PARAMETERS: Buffer - Pointer to memory region to be checked |
| * Length - Length of this memory region |
| * |
| * RETURN: Checksum (UINT8) |
| * |
| * DESCRIPTION: Calculates circular checksum of memory region. |
| * |
| ******************************************************************************/ |
| UINT8 |
| AcpiTbChecksum ( |
| UINT8 *Buffer, |
| UINT32 Length) |
| { |
| UINT8 Sum = 0; |
| UINT8 *End = Buffer + Length; |
| while (Buffer < End) |
| { |
| Sum = (UINT8) (Sum + *(Buffer++)); |
| } |
| return Sum; |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbCheckDsdtHeader |
| * |
| * PARAMETERS: None |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Quick compare to check validity of the DSDT. This will detect |
| * if the DSDT has been replaced from outside the OS and/or if |
| * the DSDT header has been corrupted. |
| * |
| ******************************************************************************/ |
| void |
| AcpiTbCheckDsdtHeader ( |
| void) |
| { |
| /* Compare original length and checksum to current values */ |
| if (AcpiGbl_OriginalDsdtHeader.Length != AcpiGbl_DSDT->Length || |
| AcpiGbl_OriginalDsdtHeader.Checksum != AcpiGbl_DSDT->Checksum) |
| { |
| ACPI_ERROR ((AE_INFO, |
| "The DSDT has been corrupted or replaced - old, new headers below")); |
| AcpiTbPrintTableHeader (0, &AcpiGbl_OriginalDsdtHeader); |
| AcpiTbPrintTableHeader (0, AcpiGbl_DSDT); |
| /* Disable further error messages */ |
| AcpiGbl_OriginalDsdtHeader.Length = AcpiGbl_DSDT->Length; |
| AcpiGbl_OriginalDsdtHeader.Checksum = AcpiGbl_DSDT->Checksum; |
| } |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbCopyDsdt |
| * |
| * PARAMETERS: TableDesc - Installed table to copy |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Implements a subsystem option to copy the DSDT to local memory. |
| * Some very bad BIOSs are known to either corrupt the DSDT or |
| * install a new, bad DSDT. This copy works around the problem. |
| * |
| ******************************************************************************/ |
| ACPI_TABLE_HEADER * |
| AcpiTbCopyDsdt ( |
| UINT32 TableIndex) |
| { |
| ACPI_TABLE_HEADER *NewTable; |
| ACPI_TABLE_DESC *TableDesc; |
| TableDesc = &AcpiGbl_RootTableList.Tables[TableIndex]; |
| NewTable = ACPI_ALLOCATE (TableDesc->Length); |
| if (!NewTable) |
| { |
| ACPI_ERROR ((AE_INFO, "Could not copy DSDT of length 0x%X", |
| TableDesc->Length)); |
| return (NULL); |
| } |
| ACPI_MEMCPY (NewTable, TableDesc->Pointer, TableDesc->Length); |
| AcpiTbDeleteTable (TableDesc); |
| TableDesc->Pointer = NewTable; |
| TableDesc->Flags = ACPI_TABLE_ORIGIN_ALLOCATED; |
| ACPI_INFO ((AE_INFO, |
| "Forced DSDT copy: length 0x%05X copied locally, original unmapped", |
| NewTable->Length)); |
| return (NewTable); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbInstallTable |
| * |
| * PARAMETERS: Address - Physical address of DSDT or FACS |
| * Signature - Table signature, NULL if no need to |
| * match |
| * TableIndex - Index into root table array |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Install an ACPI table into the global data structure. The |
| * table override mechanism is implemented here to allow the host |
| * OS to replace any table before it is installed in the root |
| * table array. |
| * |
| ******************************************************************************/ |
| void |
| AcpiTbInstallTable ( |
| ACPI_PHYSICAL_ADDRESS Address, |
| char *Signature, |
| UINT32 TableIndex) |
| { |
| UINT8 Flags; |
| ACPI_STATUS Status; |
| ACPI_TABLE_HEADER *TableToInstall; |
| ACPI_TABLE_HEADER *MappedTable; |
| ACPI_TABLE_HEADER *OverrideTable = NULL; |
| if (!Address) |
| { |
| ACPI_ERROR ((AE_INFO, "Null physical address for ACPI table [%s]", |
| Signature)); |
| return; |
| } |
| /* Map just the table header */ |
| MappedTable = AcpiOsMapMemory (Address, sizeof (ACPI_TABLE_HEADER)); |
| if (!MappedTable) |
| { |
| return; |
| } |
| /* If a particular signature is expected (DSDT/FACS), it must match */ |
| if (Signature && |
| !ACPI_COMPARE_NAME (MappedTable->Signature, Signature)) |
| { |
| ACPI_ERROR ((AE_INFO, |
| "Invalid signature 0x%X for ACPI table, expected [%s]", |
| *ACPI_CAST_PTR (UINT32, MappedTable->Signature), Signature)); |
| goto UnmapAndExit; |
| } |
| /* |
| * ACPI Table Override: |
| * |
| * Before we install the table, let the host OS override it with a new |
| * one if desired. Any table within the RSDT/XSDT can be replaced, |
| * including the DSDT which is pointed to by the FADT. |
| */ |
| Status = AcpiOsTableOverride (MappedTable, &OverrideTable); |
| if (ACPI_SUCCESS (Status) && OverrideTable) |
| { |
| ACPI_INFO ((AE_INFO, |
| "%4.4s @ 0x%p Table override, replaced with:", |
| MappedTable->Signature, ACPI_CAST_PTR (void, Address))); |
| AcpiGbl_RootTableList.Tables[TableIndex].Pointer = OverrideTable; |
| Address = ACPI_PTR_TO_PHYSADDR (OverrideTable); |
| TableToInstall = OverrideTable; |
| Flags = ACPI_TABLE_ORIGIN_OVERRIDE; |
| } |
| else |
| { |
| TableToInstall = MappedTable; |
| Flags = ACPI_TABLE_ORIGIN_MAPPED; |
| } |
| /* Initialize the table entry */ |
| AcpiGbl_RootTableList.Tables[TableIndex].Address = Address; |
| AcpiGbl_RootTableList.Tables[TableIndex].Length = TableToInstall->Length; |
| AcpiGbl_RootTableList.Tables[TableIndex].Flags = Flags; |
| ACPI_MOVE_32_TO_32 ( |
| &(AcpiGbl_RootTableList.Tables[TableIndex].Signature), |
| TableToInstall->Signature); |
| AcpiTbPrintTableHeader (Address, TableToInstall); |
| if (TableIndex == ACPI_TABLE_INDEX_DSDT) |
| { |
| /* Global integer width is based upon revision of the DSDT */ |
| AcpiUtSetIntegerWidth (TableToInstall->Revision); |
| } |
| UnmapAndExit: |
| AcpiOsUnmapMemory (MappedTable, sizeof (ACPI_TABLE_HEADER)); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbGetRootTableEntry |
| * |
| * PARAMETERS: TableEntry - Pointer to the RSDT/XSDT table entry |
| * TableEntrySize - sizeof 32 or 64 (RSDT or XSDT) |
| * |
| * RETURN: Physical address extracted from the root table |
| * |
| * DESCRIPTION: Get one root table entry. Handles 32-bit and 64-bit cases on |
| * both 32-bit and 64-bit platforms |
| * |
| * NOTE: ACPI_PHYSICAL_ADDRESS is 32-bit on 32-bit platforms, 64-bit on |
| * 64-bit platforms. |
| * |
| ******************************************************************************/ |
| static ACPI_PHYSICAL_ADDRESS |
| AcpiTbGetRootTableEntry ( |
| UINT8 *TableEntry, |
| UINT32 TableEntrySize) |
| { |
| UINT64 Address64; |
| /* |
| * Get the table physical address (32-bit for RSDT, 64-bit for XSDT): |
| * Note: Addresses are 32-bit aligned (not 64) in both RSDT and XSDT |
| */ |
| if (TableEntrySize == sizeof (UINT32)) |
| { |
| /* |
| * 32-bit platform, RSDT: Return 32-bit table entry |
| * 64-bit platform, RSDT: Expand 32-bit to 64-bit and return |
| */ |
| return ((ACPI_PHYSICAL_ADDRESS) (*ACPI_CAST_PTR (UINT32, TableEntry))); |
| } |
| else |
| { |
| /* |
| * 32-bit platform, XSDT: Truncate 64-bit to 32-bit and return |
| * 64-bit platform, XSDT: Move (unaligned) 64-bit to local, |
| * return 64-bit |
| */ |
| ACPI_MOVE_64_TO_64 (&Address64, TableEntry); |
| #if ACPI_MACHINE_WIDTH == 32 |
| if (Address64 > ACPI_UINT32_MAX) |
| { |
| /* Will truncate 64-bit address to 32 bits, issue warning */ |
| ACPI_WARNING ((AE_INFO, |
| "64-bit Physical Address in XSDT is too large (0x%8.8X%8.8X)," |
| " truncating", |
| ACPI_FORMAT_UINT64 (Address64))); |
| } |
| #endif |
| return ((ACPI_PHYSICAL_ADDRESS) (Address64)); |
| } |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbParseRootTable |
| * |
| * PARAMETERS: Rsdp - Pointer to the RSDP |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: This function is called to parse the Root System Description |
| * Table (RSDT or XSDT) |
| * |
| * NOTE: Tables are mapped (not copied) for efficiency. The FACS must |
| * be mapped and cannot be copied because it contains the actual |
| * memory location of the ACPI Global Lock. |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiTbParseRootTable ( |
| ACPI_PHYSICAL_ADDRESS RsdpAddress) |
| { |
| ACPI_TABLE_RSDP *Rsdp; |
| UINT32 TableEntrySize; |
| UINT32 i; |
| UINT32 TableCount; |
| ACPI_TABLE_HEADER *Table; |
| ACPI_PHYSICAL_ADDRESS Address; |
| UINT32 Length; |
| UINT8 *TableEntry; |
| ACPI_STATUS Status; |
| ACPI_FUNCTION_TRACE (TbParseRootTable); |
| /* |
| * Map the entire RSDP and extract the address of the RSDT or XSDT |
| */ |
| Rsdp = AcpiOsMapMemory (RsdpAddress, sizeof (ACPI_TABLE_RSDP)); |
| if (!Rsdp) |
| { |
| return_ACPI_STATUS (AE_NO_MEMORY); |
| } |
| AcpiTbPrintTableHeader (RsdpAddress, |
| ACPI_CAST_PTR (ACPI_TABLE_HEADER, Rsdp)); |
| /* Differentiate between RSDT and XSDT root tables */ |
| if (Rsdp->Revision > 1 && Rsdp->XsdtPhysicalAddress) |
| { |
| /* |
| * Root table is an XSDT (64-bit physical addresses). We must use the |
| * XSDT if the revision is > 1 and the XSDT pointer is present, as per |
| * the ACPI specification. |
| */ |
| Address = (ACPI_PHYSICAL_ADDRESS) Rsdp->XsdtPhysicalAddress; |
| TableEntrySize = sizeof (UINT64); |
| } |
| else |
| { |
| /* Root table is an RSDT (32-bit physical addresses) */ |
| Address = (ACPI_PHYSICAL_ADDRESS) Rsdp->RsdtPhysicalAddress; |
| TableEntrySize = sizeof (UINT32); |
| } |
| /* |
| * It is not possible to map more than one entry in some environments, |
| * so unmap the RSDP here before mapping other tables |
| */ |
| AcpiOsUnmapMemory (Rsdp, sizeof (ACPI_TABLE_RSDP)); |
| /* Map the RSDT/XSDT table header to get the full table length */ |
| Table = AcpiOsMapMemory (Address, sizeof (ACPI_TABLE_HEADER)); |
| if (!Table) |
| { |
| return_ACPI_STATUS (AE_NO_MEMORY); |
| } |
| AcpiTbPrintTableHeader (Address, Table); |
| /* Get the length of the full table, verify length and map entire table */ |
| Length = Table->Length; |
| AcpiOsUnmapMemory (Table, sizeof (ACPI_TABLE_HEADER)); |
| if (Length < sizeof (ACPI_TABLE_HEADER)) |
| { |
| ACPI_ERROR ((AE_INFO, "Invalid length 0x%X in RSDT/XSDT", Length)); |
| return_ACPI_STATUS (AE_INVALID_TABLE_LENGTH); |
| } |
| Table = AcpiOsMapMemory (Address, Length); |
| if (!Table) |
| { |
| return_ACPI_STATUS (AE_NO_MEMORY); |
| } |
| /* Validate the root table checksum */ |
| Status = AcpiTbVerifyChecksum (Table, Length); |
| if (ACPI_FAILURE (Status)) |
| { |
| AcpiOsUnmapMemory (Table, Length); |
| return_ACPI_STATUS (Status); |
| } |
| /* Calculate the number of tables described in the root table */ |
| TableCount = (UINT32) ((Table->Length - sizeof (ACPI_TABLE_HEADER)) / |
| TableEntrySize); |
| /* |
| * First two entries in the table array are reserved for the DSDT |
| * and FACS, which are not actually present in the RSDT/XSDT - they |
| * come from the FADT |
| */ |
| TableEntry = ACPI_CAST_PTR (UINT8, Table) + sizeof (ACPI_TABLE_HEADER); |
| AcpiGbl_RootTableList.CurrentTableCount = 2; |
| /* |
| * Initialize the root table array from the RSDT/XSDT |
| */ |
| for (i = 0; i < TableCount; i++) |
| { |
| if (AcpiGbl_RootTableList.CurrentTableCount >= |
| AcpiGbl_RootTableList.MaxTableCount) |
| { |
| /* There is no more room in the root table array, attempt resize */ |
| Status = AcpiTbResizeRootTableList (); |
| if (ACPI_FAILURE (Status)) |
| { |
| ACPI_WARNING ((AE_INFO, "Truncating %u table entries!", |
| (unsigned) (TableCount - |
| (AcpiGbl_RootTableList.CurrentTableCount - 2)))); |
| break; |
| } |
| } |
| /* Get the table physical address (32-bit for RSDT, 64-bit for XSDT) */ |
| AcpiGbl_RootTableList.Tables[AcpiGbl_RootTableList.CurrentTableCount].Address = |
| AcpiTbGetRootTableEntry (TableEntry, TableEntrySize); |
| TableEntry += TableEntrySize; |
| AcpiGbl_RootTableList.CurrentTableCount++; |
| } |
| /* |
| * It is not possible to map more than one entry in some environments, |
| * so unmap the root table here before mapping other tables |
| */ |
| AcpiOsUnmapMemory (Table, Length); |
| /* |
| * Complete the initialization of the root table array by examining |
| * the header of each table |
| */ |
| for (i = 2; i < AcpiGbl_RootTableList.CurrentTableCount; i++) |
| { |
| AcpiTbInstallTable (AcpiGbl_RootTableList.Tables[i].Address, |
| NULL, i); |
| /* Special case for FADT - get the DSDT and FACS */ |
| if (ACPI_COMPARE_NAME ( |
| &AcpiGbl_RootTableList.Tables[i].Signature, ACPI_SIG_FADT)) |
| { |
| AcpiTbParseFadt (i); |
| } |
| } |
| return_ACPI_STATUS (AE_OK); |
| } |
| /drivers/devman/acpica/tables/tbxface.c |
|---|
| 0,0 → 1,784 |
| /****************************************************************************** |
| * |
| * Module Name: tbxface - Public interfaces to the ACPI subsystem |
| * ACPI table oriented interfaces |
| * |
| *****************************************************************************/ |
| /****************************************************************************** |
| * |
| * 1. Copyright Notice |
| * |
| * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp. |
| * All rights reserved. |
| * |
| * 2. License |
| * |
| * 2.1. This is your license from Intel Corp. under its intellectual property |
| * rights. You may have additional license terms from the party that provided |
| * you this software, covering your right to use that party's intellectual |
| * property rights. |
| * |
| * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a |
| * copy of the source code appearing in this file ("Covered Code") an |
| * irrevocable, perpetual, worldwide license under Intel's copyrights in the |
| * base code distributed originally by Intel ("Original Intel Code") to copy, |
| * make derivatives, distribute, use and display any portion of the Covered |
| * Code in any form, with the right to sublicense such rights; and |
| * |
| * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent |
| * license (with the right to sublicense), under only those claims of Intel |
| * patents that are infringed by the Original Intel Code, to make, use, sell, |
| * offer to sell, and import the Covered Code and derivative works thereof |
| * solely to the minimum extent necessary to exercise the above copyright |
| * license, and in no event shall the patent license extend to any additions |
| * to or modifications of the Original Intel Code. No other license or right |
| * is granted directly or by implication, estoppel or otherwise; |
| * |
| * The above copyright and patent license is granted only if the following |
| * conditions are met: |
| * |
| * 3. Conditions |
| * |
| * 3.1. Redistribution of Source with Rights to Further Distribute Source. |
| * Redistribution of source code of any substantial portion of the Covered |
| * Code or modification with rights to further distribute source must include |
| * the above Copyright Notice, the above License, this list of Conditions, |
| * and the following Disclaimer and Export Compliance provision. In addition, |
| * Licensee must cause all Covered Code to which Licensee contributes to |
| * contain a file documenting the changes Licensee made to create that Covered |
| * Code and the date of any change. Licensee must include in that file the |
| * documentation of any changes made by any predecessor Licensee. Licensee |
| * must include a prominent statement that the modification is derived, |
| * directly or indirectly, from Original Intel Code. |
| * |
| * 3.2. Redistribution of Source with no Rights to Further Distribute Source. |
| * Redistribution of source code of any substantial portion of the Covered |
| * Code or modification without rights to further distribute source must |
| * include the following Disclaimer and Export Compliance provision in the |
| * documentation and/or other materials provided with distribution. In |
| * addition, Licensee may not authorize further sublicense of source of any |
| * portion of the Covered Code, and must include terms to the effect that the |
| * license from Licensee to its licensee is limited to the intellectual |
| * property embodied in the software Licensee provides to its licensee, and |
| * not to intellectual property embodied in modifications its licensee may |
| * make. |
| * |
| * 3.3. Redistribution of Executable. Redistribution in executable form of any |
| * substantial portion of the Covered Code or modification must reproduce the |
| * above Copyright Notice, and the following Disclaimer and Export Compliance |
| * provision in the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3.4. Intel retains all right, title, and interest in and to the Original |
| * Intel Code. |
| * |
| * 3.5. Neither the name Intel nor any other trademark owned or controlled by |
| * Intel shall be used in advertising or otherwise to promote the sale, use or |
| * other dealings in products derived from or relating to the Covered Code |
| * without prior written authorization from Intel. |
| * |
| * 4. Disclaimer and Export Compliance |
| * |
| * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED |
| * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE |
| * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, |
| * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY |
| * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY |
| * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A |
| * PARTICULAR PURPOSE. |
| * |
| * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES |
| * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR |
| * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, |
| * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY |
| * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL |
| * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS |
| * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY |
| * LIMITED REMEDY. |
| * |
| * 4.3. Licensee shall not export, either directly or indirectly, any of this |
| * software or system incorporating such software without first obtaining any |
| * required license or other approval from the U. S. Department of Commerce or |
| * any other agency or department of the United States Government. In the |
| * event Licensee exports any such software from the United States or |
| * re-exports any such software from a foreign destination, Licensee shall |
| * ensure that the distribution and export/re-export of the software is in |
| * compliance with all laws, regulations, orders, or other restrictions of the |
| * U.S. Export Administration Regulations. Licensee agrees that neither it nor |
| * any of its subsidiaries will export/re-export any technical data, process, |
| * software, or service, directly or indirectly, to any country for which the |
| * United States government or any agency thereof requires an export license, |
| * other governmental approval, or letter of assurance, without first obtaining |
| * such license, approval or letter. |
| * |
| *****************************************************************************/ |
| #define __TBXFACE_C__ |
| #include "acpi.h" |
| #include "accommon.h" |
| #include "acnamesp.h" |
| #include "actables.h" |
| #define _COMPONENT ACPI_TABLES |
| ACPI_MODULE_NAME ("tbxface") |
| /* Local prototypes */ |
| static ACPI_STATUS |
| AcpiTbLoadNamespace ( |
| void); |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiAllocateRootTable |
| * |
| * PARAMETERS: InitialTableCount - Size of InitialTableArray, in number of |
| * ACPI_TABLE_DESC structures |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Allocate a root table array. Used by iASL compiler and |
| * AcpiInitializeTables. |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiAllocateRootTable ( |
| UINT32 InitialTableCount) |
| { |
| AcpiGbl_RootTableList.MaxTableCount = InitialTableCount; |
| AcpiGbl_RootTableList.Flags = ACPI_ROOT_ALLOW_RESIZE; |
| return (AcpiTbResizeRootTableList ()); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiInitializeTables |
| * |
| * PARAMETERS: InitialTableArray - Pointer to an array of pre-allocated |
| * ACPI_TABLE_DESC structures. If NULL, the |
| * array is dynamically allocated. |
| * InitialTableCount - Size of InitialTableArray, in number of |
| * ACPI_TABLE_DESC structures |
| * AllowRealloc - Flag to tell Table Manager if resize of |
| * pre-allocated array is allowed. Ignored |
| * if InitialTableArray is NULL. |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT. |
| * |
| * NOTE: Allows static allocation of the initial table array in order |
| * to avoid the use of dynamic memory in confined environments |
| * such as the kernel boot sequence where it may not be available. |
| * |
| * If the host OS memory managers are initialized, use NULL for |
| * InitialTableArray, and the table will be dynamically allocated. |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiInitializeTables ( |
| ACPI_TABLE_DESC *InitialTableArray, |
| UINT32 InitialTableCount, |
| BOOLEAN AllowResize) |
| { |
| ACPI_PHYSICAL_ADDRESS RsdpAddress; |
| ACPI_STATUS Status; |
| ACPI_FUNCTION_TRACE (AcpiInitializeTables); |
| /* |
| * Set up the Root Table Array |
| * Allocate the table array if requested |
| */ |
| if (!InitialTableArray) |
| { |
| Status = AcpiAllocateRootTable (InitialTableCount); |
| if (ACPI_FAILURE (Status)) |
| { |
| return_ACPI_STATUS (Status); |
| } |
| } |
| else |
| { |
| /* Root Table Array has been statically allocated by the host */ |
| ACPI_MEMSET (InitialTableArray, 0, |
| (ACPI_SIZE) InitialTableCount * sizeof (ACPI_TABLE_DESC)); |
| AcpiGbl_RootTableList.Tables = InitialTableArray; |
| AcpiGbl_RootTableList.MaxTableCount = InitialTableCount; |
| AcpiGbl_RootTableList.Flags = ACPI_ROOT_ORIGIN_UNKNOWN; |
| if (AllowResize) |
| { |
| AcpiGbl_RootTableList.Flags |= ACPI_ROOT_ALLOW_RESIZE; |
| } |
| } |
| /* Get the address of the RSDP */ |
| RsdpAddress = AcpiOsGetRootPointer (); |
| if (!RsdpAddress) |
| { |
| return_ACPI_STATUS (AE_NOT_FOUND); |
| } |
| /* |
| * Get the root table (RSDT or XSDT) and extract all entries to the local |
| * Root Table Array. This array contains the information of the RSDT/XSDT |
| * in a common, more useable format. |
| */ |
| Status = AcpiTbParseRootTable (RsdpAddress); |
| return_ACPI_STATUS (Status); |
| } |
| ACPI_EXPORT_SYMBOL (AcpiInitializeTables) |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiReallocateRootTable |
| * |
| * PARAMETERS: None |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the |
| * root list from the previously provided scratch area. Should |
| * be called once dynamic memory allocation is available in the |
| * kernel |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiReallocateRootTable ( |
| void) |
| { |
| ACPI_TABLE_DESC *Tables; |
| ACPI_SIZE NewSize; |
| ACPI_SIZE CurrentSize; |
| ACPI_FUNCTION_TRACE (AcpiReallocateRootTable); |
| /* |
| * Only reallocate the root table if the host provided a static buffer |
| * for the table array in the call to AcpiInitializeTables. |
| */ |
| if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED) |
| { |
| return_ACPI_STATUS (AE_SUPPORT); |
| } |
| /* |
| * Get the current size of the root table and add the default |
| * increment to create the new table size. |
| */ |
| CurrentSize = (ACPI_SIZE) |
| AcpiGbl_RootTableList.CurrentTableCount * sizeof (ACPI_TABLE_DESC); |
| NewSize = CurrentSize + |
| (ACPI_ROOT_TABLE_SIZE_INCREMENT * sizeof (ACPI_TABLE_DESC)); |
| /* Create new array and copy the old array */ |
| Tables = ACPI_ALLOCATE_ZEROED (NewSize); |
| if (!Tables) |
| { |
| return_ACPI_STATUS (AE_NO_MEMORY); |
| } |
| ACPI_MEMCPY (Tables, AcpiGbl_RootTableList.Tables, CurrentSize); |
| /* |
| * Update the root table descriptor. The new size will be the current |
| * number of tables plus the increment, independent of the reserved |
| * size of the original table list. |
| */ |
| AcpiGbl_RootTableList.Tables = Tables; |
| AcpiGbl_RootTableList.MaxTableCount = |
| AcpiGbl_RootTableList.CurrentTableCount + ACPI_ROOT_TABLE_SIZE_INCREMENT; |
| AcpiGbl_RootTableList.Flags = |
| ACPI_ROOT_ORIGIN_ALLOCATED | ACPI_ROOT_ALLOW_RESIZE; |
| return_ACPI_STATUS (AE_OK); |
| } |
| ACPI_EXPORT_SYMBOL (AcpiReallocateRootTable) |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiGetTableHeader |
| * |
| * PARAMETERS: Signature - ACPI signature of needed table |
| * Instance - Which instance (for SSDTs) |
| * OutTableHeader - The pointer to the table header to fill |
| * |
| * RETURN: Status and pointer to mapped table header |
| * |
| * DESCRIPTION: Finds an ACPI table header. |
| * |
| * NOTE: Caller is responsible in unmapping the header with |
| * AcpiOsUnmapMemory |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiGetTableHeader ( |
| char *Signature, |
| UINT32 Instance, |
| ACPI_TABLE_HEADER *OutTableHeader) |
| { |
| UINT32 i; |
| UINT32 j; |
| ACPI_TABLE_HEADER *Header; |
| /* Parameter validation */ |
| if (!Signature || !OutTableHeader) |
| { |
| return (AE_BAD_PARAMETER); |
| } |
| /* Walk the root table list */ |
| for (i = 0, j = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++) |
| { |
| if (!ACPI_COMPARE_NAME (&(AcpiGbl_RootTableList.Tables[i].Signature), |
| Signature)) |
| { |
| continue; |
| } |
| if (++j < Instance) |
| { |
| continue; |
| } |
| if (!AcpiGbl_RootTableList.Tables[i].Pointer) |
| { |
| if ((AcpiGbl_RootTableList.Tables[i].Flags & |
| ACPI_TABLE_ORIGIN_MASK) == |
| ACPI_TABLE_ORIGIN_MAPPED) |
| { |
| Header = AcpiOsMapMemory ( |
| AcpiGbl_RootTableList.Tables[i].Address, |
| sizeof (ACPI_TABLE_HEADER)); |
| if (!Header) |
| { |
| return AE_NO_MEMORY; |
| } |
| ACPI_MEMCPY (OutTableHeader, Header, sizeof(ACPI_TABLE_HEADER)); |
| AcpiOsUnmapMemory (Header, sizeof(ACPI_TABLE_HEADER)); |
| } |
| else |
| { |
| return AE_NOT_FOUND; |
| } |
| } |
| else |
| { |
| ACPI_MEMCPY (OutTableHeader, |
| AcpiGbl_RootTableList.Tables[i].Pointer, |
| sizeof(ACPI_TABLE_HEADER)); |
| } |
| return (AE_OK); |
| } |
| return (AE_NOT_FOUND); |
| } |
| ACPI_EXPORT_SYMBOL (AcpiGetTableHeader) |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiGetTable |
| * |
| * PARAMETERS: Signature - ACPI signature of needed table |
| * Instance - Which instance (for SSDTs) |
| * OutTable - Where the pointer to the table is returned |
| * |
| * RETURN: Status and pointer to table |
| * |
| * DESCRIPTION: Finds and verifies an ACPI table. |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiGetTable ( |
| char *Signature, |
| UINT32 Instance, |
| ACPI_TABLE_HEADER **OutTable) |
| { |
| UINT32 i; |
| UINT32 j; |
| ACPI_STATUS Status; |
| /* Parameter validation */ |
| if (!Signature || !OutTable) |
| { |
| return (AE_BAD_PARAMETER); |
| } |
| /* Walk the root table list */ |
| for (i = 0, j = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++) |
| { |
| if (!ACPI_COMPARE_NAME (&(AcpiGbl_RootTableList.Tables[i].Signature), |
| Signature)) |
| { |
| continue; |
| } |
| if (++j < Instance) |
| { |
| continue; |
| } |
| Status = AcpiTbVerifyTable (&AcpiGbl_RootTableList.Tables[i]); |
| if (ACPI_SUCCESS (Status)) |
| { |
| *OutTable = AcpiGbl_RootTableList.Tables[i].Pointer; |
| } |
| return (Status); |
| } |
| return (AE_NOT_FOUND); |
| } |
| ACPI_EXPORT_SYMBOL (AcpiGetTable) |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiGetTableByIndex |
| * |
| * PARAMETERS: TableIndex - Table index |
| * Table - Where the pointer to the table is returned |
| * |
| * RETURN: Status and pointer to the table |
| * |
| * DESCRIPTION: Obtain a table by an index into the global table list. |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiGetTableByIndex ( |
| UINT32 TableIndex, |
| ACPI_TABLE_HEADER **Table) |
| { |
| ACPI_STATUS Status; |
| ACPI_FUNCTION_TRACE (AcpiGetTableByIndex); |
| /* Parameter validation */ |
| if (!Table) |
| { |
| return_ACPI_STATUS (AE_BAD_PARAMETER); |
| } |
| (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); |
| /* Validate index */ |
| if (TableIndex >= AcpiGbl_RootTableList.CurrentTableCount) |
| { |
| (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); |
| return_ACPI_STATUS (AE_BAD_PARAMETER); |
| } |
| if (!AcpiGbl_RootTableList.Tables[TableIndex].Pointer) |
| { |
| /* Table is not mapped, map it */ |
| Status = AcpiTbVerifyTable (&AcpiGbl_RootTableList.Tables[TableIndex]); |
| if (ACPI_FAILURE (Status)) |
| { |
| (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); |
| return_ACPI_STATUS (Status); |
| } |
| } |
| *Table = AcpiGbl_RootTableList.Tables[TableIndex].Pointer; |
| (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); |
| return_ACPI_STATUS (AE_OK); |
| } |
| ACPI_EXPORT_SYMBOL (AcpiGetTableByIndex) |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbLoadNamespace |
| * |
| * PARAMETERS: None |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Load the namespace from the DSDT and all SSDTs/PSDTs found in |
| * the RSDT/XSDT. |
| * |
| ******************************************************************************/ |
| static ACPI_STATUS |
| AcpiTbLoadNamespace ( |
| void) |
| { |
| ACPI_STATUS Status; |
| UINT32 i; |
| ACPI_TABLE_HEADER *NewDsdt; |
| ACPI_FUNCTION_TRACE (TbLoadNamespace); |
| (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); |
| /* |
| * Load the namespace. The DSDT is required, but any SSDT and |
| * PSDT tables are optional. Verify the DSDT. |
| */ |
| if (!AcpiGbl_RootTableList.CurrentTableCount || |
| !ACPI_COMPARE_NAME ( |
| &(AcpiGbl_RootTableList.Tables[ACPI_TABLE_INDEX_DSDT].Signature), |
| ACPI_SIG_DSDT) || |
| ACPI_FAILURE (AcpiTbVerifyTable ( |
| &AcpiGbl_RootTableList.Tables[ACPI_TABLE_INDEX_DSDT]))) |
| { |
| Status = AE_NO_ACPI_TABLES; |
| goto UnlockAndExit; |
| } |
| /* |
| * Save the DSDT pointer for simple access. This is the mapped memory |
| * address. We must take care here because the address of the .Tables |
| * array can change dynamically as tables are loaded at run-time. Note: |
| * .Pointer field is not validated until after call to AcpiTbVerifyTable. |
| */ |
| AcpiGbl_DSDT = AcpiGbl_RootTableList.Tables[ACPI_TABLE_INDEX_DSDT].Pointer; |
| /* |
| * Optionally copy the entire DSDT to local memory (instead of simply |
| * mapping it.) There are some BIOSs that corrupt or replace the original |
| * DSDT, creating the need for this option. Default is FALSE, do not copy |
| * the DSDT. |
| */ |
| if (AcpiGbl_CopyDsdtLocally) |
| { |
| NewDsdt = AcpiTbCopyDsdt (ACPI_TABLE_INDEX_DSDT); |
| if (NewDsdt) |
| { |
| AcpiGbl_DSDT = NewDsdt; |
| } |
| } |
| /* |
| * Save the original DSDT header for detection of table corruption |
| * and/or replacement of the DSDT from outside the OS. |
| */ |
| ACPI_MEMCPY (&AcpiGbl_OriginalDsdtHeader, AcpiGbl_DSDT, |
| sizeof (ACPI_TABLE_HEADER)); |
| (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); |
| /* Load and parse tables */ |
| Status = AcpiNsLoadTable (ACPI_TABLE_INDEX_DSDT, AcpiGbl_RootNode); |
| if (ACPI_FAILURE (Status)) |
| { |
| return_ACPI_STATUS (Status); |
| } |
| /* Load any SSDT or PSDT tables. Note: Loop leaves tables locked */ |
| (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); |
| for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; ++i) |
| { |
| if ((!ACPI_COMPARE_NAME (&(AcpiGbl_RootTableList.Tables[i].Signature), |
| ACPI_SIG_SSDT) && |
| !ACPI_COMPARE_NAME (&(AcpiGbl_RootTableList.Tables[i].Signature), |
| ACPI_SIG_PSDT)) || |
| ACPI_FAILURE (AcpiTbVerifyTable ( |
| &AcpiGbl_RootTableList.Tables[i]))) |
| { |
| continue; |
| } |
| /* Ignore errors while loading tables, get as many as possible */ |
| (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); |
| (void) AcpiNsLoadTable (i, AcpiGbl_RootNode); |
| (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES); |
| } |
| ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "ACPI Tables successfully acquired\n")); |
| UnlockAndExit: |
| (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES); |
| return_ACPI_STATUS (Status); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiLoadTables |
| * |
| * PARAMETERS: None |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Load the ACPI tables from the RSDT/XSDT |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiLoadTables ( |
| void) |
| { |
| ACPI_STATUS Status; |
| ACPI_FUNCTION_TRACE (AcpiLoadTables); |
| /* Load the namespace from the tables */ |
| Status = AcpiTbLoadNamespace (); |
| if (ACPI_FAILURE (Status)) |
| { |
| ACPI_EXCEPTION ((AE_INFO, Status, |
| "While loading namespace from ACPI tables")); |
| } |
| return_ACPI_STATUS (Status); |
| } |
| ACPI_EXPORT_SYMBOL (AcpiLoadTables) |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiInstallTableHandler |
| * |
| * PARAMETERS: Handler - Table event handler |
| * Context - Value passed to the handler on each event |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Install table event handler |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiInstallTableHandler ( |
| ACPI_TABLE_HANDLER Handler, |
| void *Context) |
| { |
| ACPI_STATUS Status; |
| ACPI_FUNCTION_TRACE (AcpiInstallTableHandler); |
| if (!Handler) |
| { |
| return_ACPI_STATUS (AE_BAD_PARAMETER); |
| } |
| Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS); |
| if (ACPI_FAILURE (Status)) |
| { |
| return_ACPI_STATUS (Status); |
| } |
| /* Don't allow more than one handler */ |
| if (AcpiGbl_TableHandler) |
| { |
| Status = AE_ALREADY_EXISTS; |
| goto Cleanup; |
| } |
| /* Install the handler */ |
| AcpiGbl_TableHandler = Handler; |
| AcpiGbl_TableHandlerContext = Context; |
| Cleanup: |
| (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS); |
| return_ACPI_STATUS (Status); |
| } |
| ACPI_EXPORT_SYMBOL (AcpiInstallTableHandler) |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiRemoveTableHandler |
| * |
| * PARAMETERS: Handler - Table event handler that was installed |
| * previously. |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Remove table event handler |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiRemoveTableHandler ( |
| ACPI_TABLE_HANDLER Handler) |
| { |
| ACPI_STATUS Status; |
| ACPI_FUNCTION_TRACE (AcpiRemoveTableHandler); |
| Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS); |
| if (ACPI_FAILURE (Status)) |
| { |
| return_ACPI_STATUS (Status); |
| } |
| /* Make sure that the installed handler is the same */ |
| if (!Handler || |
| Handler != AcpiGbl_TableHandler) |
| { |
| Status = AE_BAD_PARAMETER; |
| goto Cleanup; |
| } |
| /* Remove the handler */ |
| AcpiGbl_TableHandler = NULL; |
| Cleanup: |
| (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS); |
| return_ACPI_STATUS (Status); |
| } |
| ACPI_EXPORT_SYMBOL (AcpiRemoveTableHandler) |
| /drivers/devman/acpica/tables/tbxfroot.c |
|---|
| 0,0 → 1,371 |
| /****************************************************************************** |
| * |
| * Module Name: tbxfroot - Find the root ACPI table (RSDT) |
| * |
| *****************************************************************************/ |
| /****************************************************************************** |
| * |
| * 1. Copyright Notice |
| * |
| * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp. |
| * All rights reserved. |
| * |
| * 2. License |
| * |
| * 2.1. This is your license from Intel Corp. under its intellectual property |
| * rights. You may have additional license terms from the party that provided |
| * you this software, covering your right to use that party's intellectual |
| * property rights. |
| * |
| * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a |
| * copy of the source code appearing in this file ("Covered Code") an |
| * irrevocable, perpetual, worldwide license under Intel's copyrights in the |
| * base code distributed originally by Intel ("Original Intel Code") to copy, |
| * make derivatives, distribute, use and display any portion of the Covered |
| * Code in any form, with the right to sublicense such rights; and |
| * |
| * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent |
| * license (with the right to sublicense), under only those claims of Intel |
| * patents that are infringed by the Original Intel Code, to make, use, sell, |
| * offer to sell, and import the Covered Code and derivative works thereof |
| * solely to the minimum extent necessary to exercise the above copyright |
| * license, and in no event shall the patent license extend to any additions |
| * to or modifications of the Original Intel Code. No other license or right |
| * is granted directly or by implication, estoppel or otherwise; |
| * |
| * The above copyright and patent license is granted only if the following |
| * conditions are met: |
| * |
| * 3. Conditions |
| * |
| * 3.1. Redistribution of Source with Rights to Further Distribute Source. |
| * Redistribution of source code of any substantial portion of the Covered |
| * Code or modification with rights to further distribute source must include |
| * the above Copyright Notice, the above License, this list of Conditions, |
| * and the following Disclaimer and Export Compliance provision. In addition, |
| * Licensee must cause all Covered Code to which Licensee contributes to |
| * contain a file documenting the changes Licensee made to create that Covered |
| * Code and the date of any change. Licensee must include in that file the |
| * documentation of any changes made by any predecessor Licensee. Licensee |
| * must include a prominent statement that the modification is derived, |
| * directly or indirectly, from Original Intel Code. |
| * |
| * 3.2. Redistribution of Source with no Rights to Further Distribute Source. |
| * Redistribution of source code of any substantial portion of the Covered |
| * Code or modification without rights to further distribute source must |
| * include the following Disclaimer and Export Compliance provision in the |
| * documentation and/or other materials provided with distribution. In |
| * addition, Licensee may not authorize further sublicense of source of any |
| * portion of the Covered Code, and must include terms to the effect that the |
| * license from Licensee to its licensee is limited to the intellectual |
| * property embodied in the software Licensee provides to its licensee, and |
| * not to intellectual property embodied in modifications its licensee may |
| * make. |
| * |
| * 3.3. Redistribution of Executable. Redistribution in executable form of any |
| * substantial portion of the Covered Code or modification must reproduce the |
| * above Copyright Notice, and the following Disclaimer and Export Compliance |
| * provision in the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3.4. Intel retains all right, title, and interest in and to the Original |
| * Intel Code. |
| * |
| * 3.5. Neither the name Intel nor any other trademark owned or controlled by |
| * Intel shall be used in advertising or otherwise to promote the sale, use or |
| * other dealings in products derived from or relating to the Covered Code |
| * without prior written authorization from Intel. |
| * |
| * 4. Disclaimer and Export Compliance |
| * |
| * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED |
| * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE |
| * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, |
| * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY |
| * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY |
| * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A |
| * PARTICULAR PURPOSE. |
| * |
| * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES |
| * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR |
| * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, |
| * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY |
| * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL |
| * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS |
| * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY |
| * LIMITED REMEDY. |
| * |
| * 4.3. Licensee shall not export, either directly or indirectly, any of this |
| * software or system incorporating such software without first obtaining any |
| * required license or other approval from the U. S. Department of Commerce or |
| * any other agency or department of the United States Government. In the |
| * event Licensee exports any such software from the United States or |
| * re-exports any such software from a foreign destination, Licensee shall |
| * ensure that the distribution and export/re-export of the software is in |
| * compliance with all laws, regulations, orders, or other restrictions of the |
| * U.S. Export Administration Regulations. Licensee agrees that neither it nor |
| * any of its subsidiaries will export/re-export any technical data, process, |
| * software, or service, directly or indirectly, to any country for which the |
| * United States government or any agency thereof requires an export license, |
| * other governmental approval, or letter of assurance, without first obtaining |
| * such license, approval or letter. |
| * |
| *****************************************************************************/ |
| #define __TBXFROOT_C__ |
| #include "acpi.h" |
| #include "accommon.h" |
| #include "actables.h" |
| #define _COMPONENT ACPI_TABLES |
| ACPI_MODULE_NAME ("tbxfroot") |
| /* Local prototypes */ |
| static UINT8 * |
| AcpiTbScanMemoryForRsdp ( |
| UINT8 *StartAddress, |
| UINT32 Length); |
| static ACPI_STATUS |
| AcpiTbValidateRsdp ( |
| ACPI_TABLE_RSDP *Rsdp); |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbValidateRsdp |
| * |
| * PARAMETERS: Rsdp - Pointer to unvalidated RSDP |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Validate the RSDP (ptr) |
| * |
| ******************************************************************************/ |
| static ACPI_STATUS |
| AcpiTbValidateRsdp ( |
| ACPI_TABLE_RSDP *Rsdp) |
| { |
| ACPI_FUNCTION_ENTRY (); |
| /* |
| * The signature and checksum must both be correct |
| * |
| * Note: Sometimes there exists more than one RSDP in memory; the valid |
| * RSDP has a valid checksum, all others have an invalid checksum. |
| */ |
| if (ACPI_STRNCMP ((char *) Rsdp, ACPI_SIG_RSDP, |
| sizeof (ACPI_SIG_RSDP)-1) != 0) |
| { |
| /* Nope, BAD Signature */ |
| return (AE_BAD_SIGNATURE); |
| } |
| /* Check the standard checksum */ |
| if (AcpiTbChecksum ((UINT8 *) Rsdp, ACPI_RSDP_CHECKSUM_LENGTH) != 0) |
| { |
| return (AE_BAD_CHECKSUM); |
| } |
| /* Check extended checksum if table version >= 2 */ |
| if ((Rsdp->Revision >= 2) && |
| (AcpiTbChecksum ((UINT8 *) Rsdp, ACPI_RSDP_XCHECKSUM_LENGTH) != 0)) |
| { |
| return (AE_BAD_CHECKSUM); |
| } |
| return (AE_OK); |
| } |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiFindRootPointer |
| * |
| * PARAMETERS: TableAddress - Where the table pointer is returned |
| * |
| * RETURN: Status, RSDP physical address |
| * |
| * DESCRIPTION: Search lower 1Mbyte of memory for the root system descriptor |
| * pointer structure. If it is found, set *RSDP to point to it. |
| * |
| * NOTE1: The RSDP must be either in the first 1K of the Extended |
| * BIOS Data Area or between E0000 and FFFFF (From ACPI Spec.) |
| * Only a 32-bit physical address is necessary. |
| * |
| * NOTE2: This function is always available, regardless of the |
| * initialization state of the rest of ACPI. |
| * |
| ******************************************************************************/ |
| ACPI_STATUS |
| AcpiFindRootPointer ( |
| ACPI_SIZE *TableAddress) |
| { |
| UINT8 *TablePtr; |
| UINT8 *MemRover; |
| UINT32 PhysicalAddress; |
| ACPI_FUNCTION_TRACE (AcpiFindRootPointer); |
| /* 1a) Get the location of the Extended BIOS Data Area (EBDA) */ |
| TablePtr = AcpiOsMapMemory ( |
| (ACPI_PHYSICAL_ADDRESS) ACPI_EBDA_PTR_LOCATION, |
| ACPI_EBDA_PTR_LENGTH); |
| if (!TablePtr) |
| { |
| ACPI_ERROR ((AE_INFO, |
| "Could not map memory at 0x%8.8X for length %u", |
| ACPI_EBDA_PTR_LOCATION, ACPI_EBDA_PTR_LENGTH)); |
| return_ACPI_STATUS (AE_NO_MEMORY); |
| } |
| ACPI_MOVE_16_TO_32 (&PhysicalAddress, TablePtr); |
| /* Convert segment part to physical address */ |
| PhysicalAddress <<= 4; |
| AcpiOsUnmapMemory (TablePtr, ACPI_EBDA_PTR_LENGTH); |
| /* EBDA present? */ |
| if (PhysicalAddress > 0x400) |
| { |
| /* |
| * 1b) Search EBDA paragraphs (EBDA is required to be a |
| * minimum of 1K length) |
| */ |
| TablePtr = AcpiOsMapMemory ( |
| (ACPI_PHYSICAL_ADDRESS) PhysicalAddress, |
| ACPI_EBDA_WINDOW_SIZE); |
| if (!TablePtr) |
| { |
| ACPI_ERROR ((AE_INFO, |
| "Could not map memory at 0x%8.8X for length %u", |
| PhysicalAddress, ACPI_EBDA_WINDOW_SIZE)); |
| return_ACPI_STATUS (AE_NO_MEMORY); |
| } |
| MemRover = AcpiTbScanMemoryForRsdp (TablePtr, ACPI_EBDA_WINDOW_SIZE); |
| AcpiOsUnmapMemory (TablePtr, ACPI_EBDA_WINDOW_SIZE); |
| if (MemRover) |
| { |
| /* Return the physical address */ |
| PhysicalAddress += (UINT32) ACPI_PTR_DIFF (MemRover, TablePtr); |
| *TableAddress = PhysicalAddress; |
| return_ACPI_STATUS (AE_OK); |
| } |
| } |
| /* |
| * 2) Search upper memory: 16-byte boundaries in E0000h-FFFFFh |
| */ |
| TablePtr = AcpiOsMapMemory ( |
| (ACPI_PHYSICAL_ADDRESS) ACPI_HI_RSDP_WINDOW_BASE, |
| ACPI_HI_RSDP_WINDOW_SIZE); |
| if (!TablePtr) |
| { |
| ACPI_ERROR ((AE_INFO, |
| "Could not map memory at 0x%8.8X for length %u", |
| ACPI_HI_RSDP_WINDOW_BASE, ACPI_HI_RSDP_WINDOW_SIZE)); |
| return_ACPI_STATUS (AE_NO_MEMORY); |
| } |
| MemRover = AcpiTbScanMemoryForRsdp (TablePtr, ACPI_HI_RSDP_WINDOW_SIZE); |
| AcpiOsUnmapMemory (TablePtr, ACPI_HI_RSDP_WINDOW_SIZE); |
| if (MemRover) |
| { |
| /* Return the physical address */ |
| PhysicalAddress = (UINT32) |
| (ACPI_HI_RSDP_WINDOW_BASE + ACPI_PTR_DIFF (MemRover, TablePtr)); |
| *TableAddress = PhysicalAddress; |
| return_ACPI_STATUS (AE_OK); |
| } |
| /* A valid RSDP was not found */ |
| ACPI_ERROR ((AE_INFO, "A valid RSDP was not found")); |
| return_ACPI_STATUS (AE_NOT_FOUND); |
| } |
| ACPI_EXPORT_SYMBOL (AcpiFindRootPointer) |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiTbScanMemoryForRsdp |
| * |
| * PARAMETERS: StartAddress - Starting pointer for search |
| * Length - Maximum length to search |
| * |
| * RETURN: Pointer to the RSDP if found, otherwise NULL. |
| * |
| * DESCRIPTION: Search a block of memory for the RSDP signature |
| * |
| ******************************************************************************/ |
| static UINT8 * |
| AcpiTbScanMemoryForRsdp ( |
| UINT8 *StartAddress, |
| UINT32 Length) |
| { |
| ACPI_STATUS Status; |
| UINT8 *MemRover; |
| UINT8 *EndAddress; |
| ACPI_FUNCTION_TRACE (TbScanMemoryForRsdp); |
| EndAddress = StartAddress + Length; |
| /* Search from given start address for the requested length */ |
| for (MemRover = StartAddress; MemRover < EndAddress; |
| MemRover += ACPI_RSDP_SCAN_STEP) |
| { |
| /* The RSDP signature and checksum must both be correct */ |
| Status = AcpiTbValidateRsdp (ACPI_CAST_PTR (ACPI_TABLE_RSDP, MemRover)); |
| if (ACPI_SUCCESS (Status)) |
| { |
| /* Sig and checksum valid, we have found a real RSDP */ |
| ACPI_DEBUG_PRINT ((ACPI_DB_INFO, |
| "RSDP located at physical address %p\n", MemRover)); |
| return_PTR (MemRover); |
| } |
| /* No sig match or bad checksum, keep searching */ |
| } |
| /* Searched entire block, no RSDP was found */ |
| ACPI_DEBUG_PRINT ((ACPI_DB_INFO, |
| "Searched entire block from %p, valid RSDP was not found\n", |
| StartAddress)); |
| return_PTR (NULL); |
| } |