Import ACPICA 20140627.vendor/acpica/20140627

6 files changed, 2756 insertions, 20 deletions

diff --git a/source/os_specific/service_layers/osefitbl.c b/source/os_specific/service_layers/osefitbl.c
new file mode 100644
index 000000000000..341f3ddd3523
--- /dev/null
+++ b/source/os_specific/service_layers/osefitbl.c
@@ -0,0 +1,1033 @@
+/******************************************************************************
+ *
+ * Module Name: osefitbl - EFI OSL for obtaining ACPI tables
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2014, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include "acpidump.h"
+
+
+#define _COMPONENT          ACPI_OS_SERVICES
+        ACPI_MODULE_NAME    ("osefitbl")
+
+
+#ifndef PATH_MAX
+#define PATH_MAX 256
+#endif
+
+
+/* List of information about obtained ACPI tables */
+
+typedef struct osl_table_info
+{
+    struct osl_table_info   *Next;
+    UINT32                  Instance;
+    char                    Signature[ACPI_NAME_SIZE];
+
+} OSL_TABLE_INFO;
+
+/* Local prototypes */
+
+static ACPI_STATUS
+OslTableInitialize (
+    void);
+
+static ACPI_STATUS
+OslAddTableToList (
+    char                    *Signature,
+    UINT32                  Instance);
+
+static ACPI_STATUS
+OslMapTable (
+    ACPI_SIZE               Address,
+    char                    *Signature,
+    ACPI_TABLE_HEADER       **Table);
+
+static void
+OslUnmapTable (
+    ACPI_TABLE_HEADER       *Table);
+
+static ACPI_STATUS
+OslLoadRsdp (
+    void);
+
+static ACPI_STATUS
+OslListTables (
+    void);
+
+static ACPI_STATUS
+OslGetTable (
+    char                    *Signature,
+    UINT32                  Instance,
+    ACPI_TABLE_HEADER       **Table,
+    ACPI_PHYSICAL_ADDRESS   *Address);
+
+
+/* File locations */
+
+#define EFI_SYSTAB          "/sys/firmware/efi/systab"
+
+/* Initialization flags */
+
+UINT8                   Gbl_TableListInitialized = FALSE;
+
+/* Local copies of main ACPI tables */
+
+ACPI_TABLE_RSDP         Gbl_Rsdp;
+ACPI_TABLE_FADT         *Gbl_Fadt = NULL;
+ACPI_TABLE_RSDT         *Gbl_Rsdt = NULL;
+ACPI_TABLE_XSDT         *Gbl_Xsdt = NULL;
+
+/* Table addresses */
+
+ACPI_PHYSICAL_ADDRESS   Gbl_FadtAddress = 0;
+ACPI_PHYSICAL_ADDRESS   Gbl_RsdpAddress = 0;
+
+/* Revision of RSD PTR */
+
+UINT8                   Gbl_Revision = 0;
+
+OSL_TABLE_INFO          *Gbl_TableListHead = NULL;
+UINT32                  Gbl_TableCount = 0;
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiOsGetTableByAddress
+ *
+ * PARAMETERS:  Address         - Physical address of the ACPI table
+ *              Table           - Where a pointer to the table is returned
+ *
+ * RETURN:      Status; Table buffer is returned if AE_OK.
+ *              AE_NOT_FOUND: A valid table was not found at the address
+ *
+ * DESCRIPTION: Get an ACPI table via a physical memory address.
+ *
+ *****************************************************************************/
+
+ACPI_STATUS
+AcpiOsGetTableByAddress (
+    ACPI_PHYSICAL_ADDRESS   Address,
+    ACPI_TABLE_HEADER       **Table)
+{
+    UINT32                  TableLength;
+    ACPI_TABLE_HEADER       *MappedTable;
+    ACPI_TABLE_HEADER       *LocalTable = NULL;
+    ACPI_STATUS             Status = AE_OK;
+
+
+    /* Get main ACPI tables from memory on first invocation of this function */
+
+    Status = OslTableInitialize ();
+    if (ACPI_FAILURE (Status))
+    {
+        return (Status);
+    }
+
+    /* Map the table and validate it */
+
+    Status = OslMapTable (Address, NULL, &MappedTable);
+    if (ACPI_FAILURE (Status))
+    {
+        return (Status);
+    }
+
+    /* Copy table to local buffer and return it */
+
+    TableLength = ApGetTableLength (MappedTable);
+    if (TableLength == 0)
+    {
+        Status = AE_BAD_HEADER;
+        goto Exit;
+    }
+
+    LocalTable = ACPI_ALLOCATE_ZEROED (TableLength);
+    if (!LocalTable)
+    {
+        Status = AE_NO_MEMORY;
+        goto Exit;
+    }
+
+    ACPI_MEMCPY (LocalTable, MappedTable, TableLength);
+
+Exit:
+    OslUnmapTable (MappedTable);
+    *Table = LocalTable;
+    return (Status);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiOsGetTableByName
+ *
+ * PARAMETERS:  Signature       - ACPI Signature for desired table. Must be
+ *                                a null terminated 4-character string.
+ *              Instance        - Multiple table support for SSDT/UEFI (0...n)
+ *                                Must be 0 for other tables.
+ *              Table           - Where a pointer to the table is returned
+ *              Address         - Where the table physical address is returned
+ *
+ * RETURN:      Status; Table buffer and physical address returned if AE_OK.
+ *              AE_LIMIT: Instance is beyond valid limit
+ *              AE_NOT_FOUND: A table with the signature was not found
+ *
+ * NOTE:        Assumes the input signature is uppercase.
+ *
+ *****************************************************************************/
+
+ACPI_STATUS
+AcpiOsGetTableByName (
+    char                    *Signature,
+    UINT32                  Instance,
+    ACPI_TABLE_HEADER       **Table,
+    ACPI_PHYSICAL_ADDRESS   *Address)
+{
+    ACPI_STATUS             Status;
+
+
+    /* Get main ACPI tables from memory on first invocation of this function */
+
+    Status = OslTableInitialize ();
+    if (ACPI_FAILURE (Status))
+    {
+        return (Status);
+    }
+
+    /* Not a main ACPI table, attempt to extract it from the RSDT/XSDT */
+
+    if (!Gbl_DumpCustomizedTables)
+    {
+        /* Attempt to get the table from the memory */
+
+        Status = OslGetTable (Signature, Instance, Table, Address);
+    }
+    else
+    {
+        /* Attempt to get the table from the static directory */
+
+        Status = AE_SUPPORT;
+    }
+
+    return (Status);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    OslAddTableToList
+ *
+ * PARAMETERS:  Signature       - Table signature
+ *              Instance        - Table instance
+ *
+ * RETURN:      Status; Successfully added if AE_OK.
+ *              AE_NO_MEMORY: Memory allocation error
+ *
+ * DESCRIPTION: Insert a table structure into OSL table list.
+ *
+ *****************************************************************************/
+
+static ACPI_STATUS
+OslAddTableToList (
+    char                    *Signature,
+    UINT32                  Instance)
+{
+    OSL_TABLE_INFO          *NewInfo;
+    OSL_TABLE_INFO          *Next;
+    UINT32                  NextInstance = 0;
+    BOOLEAN                 Found = FALSE;
+
+
+    NewInfo = ACPI_ALLOCATE_ZEROED (sizeof (OSL_TABLE_INFO));
+    if (!NewInfo)
+    {
+        return (AE_NO_MEMORY);
+    }
+
+    ACPI_MOVE_NAME (NewInfo->Signature, Signature);
+
+    if (!Gbl_TableListHead)
+    {
+        Gbl_TableListHead = NewInfo;
+    }
+    else
+    {
+        Next = Gbl_TableListHead;
+        while (1)
+        {
+            if (ACPI_COMPARE_NAME (Next->Signature, Signature))
+            {
+                if (Next->Instance == Instance)
+                {
+                    Found = TRUE;
+                }
+                if (Next->Instance >= NextInstance)
+                {
+                    NextInstance = Next->Instance + 1;
+                }
+            }
+
+            if (!Next->Next)
+            {
+                break;
+            }
+            Next = Next->Next;
+        }
+        Next->Next = NewInfo;
+    }
+
+    if (Found)
+    {
+        if (Instance)
+        {
+            AcpiLogError (
+                "%4.4s: Warning unmatched table instance %d, expected %d\n",
+                Signature, Instance, NextInstance);
+        }
+        Instance = NextInstance;
+    }
+
+    NewInfo->Instance = Instance;
+    Gbl_TableCount++;
+
+    return (AE_OK);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiOsGetTableByIndex
+ *
+ * PARAMETERS:  Index           - Which table to get
+ *              Table           - Where a pointer to the table is returned
+ *              Instance        - Where a pointer to the table instance no. is
+ *                                returned
+ *              Address         - Where the table physical address is returned
+ *
+ * RETURN:      Status; Table buffer and physical address returned if AE_OK.
+ *              AE_LIMIT: Index is beyond valid limit
+ *
+ * DESCRIPTION: Get an ACPI table via an index value (0 through n). Returns
+ *              AE_LIMIT when an invalid index is reached. Index is not
+ *              necessarily an index into the RSDT/XSDT.
+ *
+ *****************************************************************************/
+
+ACPI_STATUS
+AcpiOsGetTableByIndex (
+    UINT32                  Index,
+    ACPI_TABLE_HEADER       **Table,
+    UINT32                  *Instance,
+    ACPI_PHYSICAL_ADDRESS   *Address)
+{
+    OSL_TABLE_INFO          *Info;
+    ACPI_STATUS             Status;
+    UINT32                  i;
+
+
+    /* Get main ACPI tables from memory on first invocation of this function */
+
+    Status = OslTableInitialize ();
+    if (ACPI_FAILURE (Status))
+    {
+        return (Status);
+    }
+
+    /* Validate Index */
+
+    if (Index >= Gbl_TableCount)
+    {
+        return (AE_LIMIT);
+    }
+
+    /* Point to the table list entry specified by the Index argument */
+
+    Info = Gbl_TableListHead;
+    for (i = 0; i < Index; i++)
+    {
+        Info = Info->Next;
+    }
+
+    /* Now we can just get the table via the signature */
+
+    Status = AcpiOsGetTableByName (Info->Signature, Info->Instance,
+        Table, Address);
+
+    if (ACPI_SUCCESS (Status))
+    {
+        *Instance = Info->Instance;
+    }
+    return (Status);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    OslLoadRsdp
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Scan and load RSDP.
+ *
+ *****************************************************************************/
+
+static ACPI_STATUS
+OslLoadRsdp (
+    void)
+{
+    ACPI_TABLE_HEADER       *MappedTable;
+    UINT8                   *RsdpAddress;
+    ACPI_PHYSICAL_ADDRESS   RsdpBase;
+    ACPI_SIZE               RsdpSize;
+
+
+    /* Get RSDP from memory */
+
+    RsdpSize = sizeof (ACPI_TABLE_RSDP);
+    if (Gbl_RsdpBase)
+    {
+        RsdpBase = Gbl_RsdpBase;
+    }
+    else
+    {
+        RsdpBase = AcpiOsGetRootPointer ();
+    }
+
+    if (!RsdpBase)
+    {
+        RsdpBase = ACPI_HI_RSDP_WINDOW_BASE;
+        RsdpSize = ACPI_HI_RSDP_WINDOW_SIZE;
+    }
+
+    RsdpAddress = AcpiOsMapMemory (RsdpBase, RsdpSize);
+    if (!RsdpAddress)
+    {
+        return (AE_BAD_ADDRESS);
+    }
+
+    /* Search low memory for the RSDP */
+
+    MappedTable = ACPI_CAST_PTR (ACPI_TABLE_HEADER,
+        AcpiTbScanMemoryForRsdp (RsdpAddress, RsdpSize));
+    if (!MappedTable)
+    {
+        AcpiOsUnmapMemory (RsdpAddress, RsdpSize);
+        return (AE_NOT_FOUND);
+    }
+
+    Gbl_RsdpAddress = RsdpBase + (ACPI_CAST8 (MappedTable) - RsdpAddress);
+
+    ACPI_MEMCPY (&Gbl_Rsdp, MappedTable, sizeof (ACPI_TABLE_RSDP));
+    AcpiOsUnmapMemory (RsdpAddress, RsdpSize);
+
+    return (AE_OK);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    OslCanUseXsdt
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      TRUE if XSDT is allowed to be used.
+ *
+ * DESCRIPTION: This function collects logic that can be used to determine if
+ *              XSDT should be used instead of RSDT.
+ *
+ *****************************************************************************/
+
+static BOOLEAN
+OslCanUseXsdt (
+    void)
+{
+    if (Gbl_Revision && !AcpiGbl_DoNotUseXsdt)
+    {
+        return (TRUE);
+    }
+    else
+    {
+        return (FALSE);
+    }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    OslTableInitialize
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Initialize ACPI table data. Get and store main ACPI tables to
+ *              local variables. Main ACPI tables include RSDT, FADT, RSDT,
+ *              and/or XSDT.
+ *
+ *****************************************************************************/
+
+static ACPI_STATUS
+OslTableInitialize (
+    void)
+{
+    ACPI_STATUS             Status;
+    ACPI_PHYSICAL_ADDRESS   Address;
+
+
+    if (Gbl_TableListInitialized)
+    {
+        return (AE_OK);
+    }
+
+    /* Get RSDP from memory */
+
+    Status = OslLoadRsdp ();
+    if (ACPI_FAILURE (Status))
+    {
+        return (Status);
+    }
+
+    /* Get XSDT from memory */
+
+    if (Gbl_Rsdp.Revision && !Gbl_DoNotDumpXsdt)
+    {
+        if (Gbl_Xsdt)
+        {
+            ACPI_FREE (Gbl_Xsdt);
+            Gbl_Xsdt = NULL;
+        }
+
+        Gbl_Revision = 2;
+        Status = OslGetTable (ACPI_SIG_XSDT, 0,
+            ACPI_CAST_PTR (ACPI_TABLE_HEADER *, &Gbl_Xsdt), &Address);
+        if (ACPI_FAILURE (Status))
+        {
+            return (Status);
+        }
+    }
+
+    /* Get RSDT from memory */
+
+    if (Gbl_Rsdp.RsdtPhysicalAddress)
+    {
+        if (Gbl_Rsdt)
+        {
+            ACPI_FREE (Gbl_Rsdt);
+            Gbl_Rsdt = NULL;
+        }
+
+        Status = OslGetTable (ACPI_SIG_RSDT, 0,
+            ACPI_CAST_PTR (ACPI_TABLE_HEADER *, &Gbl_Rsdt), &Address);
+        if (ACPI_FAILURE (Status))
+        {
+            return (Status);
+        }
+    }
+
+    /* Get FADT from memory */
+
+    if (Gbl_Fadt)
+    {
+        ACPI_FREE (Gbl_Fadt);
+        Gbl_Fadt = NULL;
+    }
+
+    Status = OslGetTable (ACPI_SIG_FADT, 0,
+        ACPI_CAST_PTR (ACPI_TABLE_HEADER *, &Gbl_Fadt), &Gbl_FadtAddress);
+    if (ACPI_FAILURE (Status))
+    {
+        return (Status);
+    }
+
+    if (!Gbl_DumpCustomizedTables)
+    {
+        /* Add mandatory tables to global table list first */
+
+        Status = OslAddTableToList (ACPI_RSDP_NAME, 0);
+        if (ACPI_FAILURE (Status))
+        {
+            return (Status);
+        }
+
+        Status = OslAddTableToList (ACPI_SIG_RSDT, 0);
+        if (ACPI_FAILURE (Status))
+        {
+            return (Status);
+        }
+
+        if (Gbl_Revision == 2)
+        {
+            Status = OslAddTableToList (ACPI_SIG_XSDT, 0);
+            if (ACPI_FAILURE (Status))
+            {
+                return (Status);
+            }
+        }
+
+        Status = OslAddTableToList (ACPI_SIG_DSDT, 0);
+        if (ACPI_FAILURE (Status))
+        {
+            return (Status);
+        }
+
+        Status = OslAddTableToList (ACPI_SIG_FACS, 0);
+        if (ACPI_FAILURE (Status))
+        {
+            return (Status);
+        }
+
+        /* Add all tables found in the memory */
+
+        Status = OslListTables ();
+        if (ACPI_FAILURE (Status))
+        {
+            return (Status);
+        }
+    }
+    else
+    {
+        /* Add all tables found in the static directory */
+
+        Status = AE_SUPPORT;
+    }
+
+    Gbl_TableListInitialized = TRUE;
+    return (AE_OK);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    OslListTables
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Status; Table list is initialized if AE_OK.
+ *
+ * DESCRIPTION: Add ACPI tables to the table list from memory.
+ *
+ *****************************************************************************/
+
+static ACPI_STATUS
+OslListTables (
+    void)
+{
+    ACPI_TABLE_HEADER       *MappedTable = NULL;
+    UINT8                   *TableData;
+    UINT8                   NumberOfTables;
+    UINT8                   ItemSize;
+    ACPI_PHYSICAL_ADDRESS   TableAddress = 0;
+    ACPI_STATUS             Status = AE_OK;
+    UINT32                  i;
+
+
+    if (OslCanUseXsdt ())
+    {
+        ItemSize = sizeof (UINT64);
+        TableData = ACPI_CAST8 (Gbl_Xsdt) + sizeof (ACPI_TABLE_HEADER);
+        NumberOfTables =
+            (UINT8) ((Gbl_Xsdt->Header.Length - sizeof (ACPI_TABLE_HEADER))
+            / ItemSize);
+    }
+    else /* Use RSDT if XSDT is not available */
+    {
+        ItemSize = sizeof (UINT32);
+        TableData = ACPI_CAST8 (Gbl_Rsdt) + sizeof (ACPI_TABLE_HEADER);
+        NumberOfTables =
+            (UINT8) ((Gbl_Rsdt->Header.Length - sizeof (ACPI_TABLE_HEADER))
+            / ItemSize);
+    }
+
+    /* Search RSDT/XSDT for the requested table */
+
+    for (i = 0; i < NumberOfTables; ++i, TableData += ItemSize)
+    {
+        if (OslCanUseXsdt ())
+        {
+            TableAddress =
+                (ACPI_PHYSICAL_ADDRESS) (*ACPI_CAST64 (TableData));
+        }
+        else
+        {
+            TableAddress =
+                (ACPI_PHYSICAL_ADDRESS) (*ACPI_CAST32 (TableData));
+        }
+
+        /* Skip NULL entries in RSDT/XSDT */
+
+        if (!TableAddress)
+        {
+            continue;
+        }
+
+        Status = OslMapTable (TableAddress, NULL, &MappedTable);
+        if (ACPI_FAILURE (Status))
+        {
+            return (Status);
+        }
+
+        OslAddTableToList (MappedTable->Signature, 0);
+        OslUnmapTable (MappedTable);
+    }
+
+    return (AE_OK);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    OslGetTable
+ *
+ * PARAMETERS:  Signature       - ACPI Signature for common table. Must be
+ *                                a null terminated 4-character string.
+ *              Instance        - Multiple table support for SSDT/UEFI (0...n)
+ *                                Must be 0 for other tables.
+ *              Table           - Where a pointer to the table is returned
+ *              Address         - Where the table physical address is returned
+ *
+ * RETURN:      Status; Table buffer and physical address returned if AE_OK.
+ *              AE_LIMIT: Instance is beyond valid limit
+ *              AE_NOT_FOUND: A table with the signature was not found
+ *
+ * DESCRIPTION: Get a BIOS provided ACPI table
+ *
+ * NOTE:        Assumes the input signature is uppercase.
+ *
+ *****************************************************************************/
+
+static ACPI_STATUS
+OslGetTable (
+    char                    *Signature,
+    UINT32                  Instance,
+    ACPI_TABLE_HEADER       **Table,
+    ACPI_PHYSICAL_ADDRESS   *Address)
+{
+    ACPI_TABLE_HEADER       *LocalTable = NULL;
+    ACPI_TABLE_HEADER       *MappedTable = NULL;
+    UINT8                   *TableData;
+    UINT8                   NumberOfTables;
+    UINT8                   ItemSize;
+    UINT32                  CurrentInstance = 0;
+    ACPI_PHYSICAL_ADDRESS   TableAddress = 0;
+    UINT32                  TableLength = 0;
+    ACPI_STATUS             Status = AE_OK;
+    UINT32                  i;
+
+
+    /* Handle special tables whose addresses are not in RSDT/XSDT */
+
+    if (ACPI_COMPARE_NAME (Signature, ACPI_RSDP_NAME) ||
+        ACPI_COMPARE_NAME (Signature, ACPI_SIG_RSDT) ||
+        ACPI_COMPARE_NAME (Signature, ACPI_SIG_XSDT) ||
+        ACPI_COMPARE_NAME (Signature, ACPI_SIG_DSDT) ||
+        ACPI_COMPARE_NAME (Signature, ACPI_SIG_FACS))
+    {
+        /*
+         * Get the appropriate address, either 32-bit or 64-bit. Be very
+         * careful about the FADT length and validate table addresses.
+         * Note: The 64-bit addresses have priority.
+         */
+        if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_DSDT))
+        {
+            if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_XDSDT) &&
+                Gbl_Fadt->XDsdt)
+            {
+                TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->XDsdt;
+            }
+            else if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_DSDT) &&
+                Gbl_Fadt->Dsdt)
+            {
+                TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->Dsdt;
+            }
+        }
+        else if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_FACS))
+        {
+            if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_XFACS) &&
+                Gbl_Fadt->XFacs)
+            {
+                TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->XFacs;
+            }
+            else if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_FACS) &&
+                Gbl_Fadt->Facs)
+            {
+                TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->Facs;
+            }
+        }
+        else if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_XSDT))
+        {
+            if (!Gbl_Revision)
+            {
+                return (AE_BAD_SIGNATURE);
+            }
+            TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Rsdp.XsdtPhysicalAddress;
+        }
+        else if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_RSDT))
+        {
+            TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Rsdp.RsdtPhysicalAddress;
+        }
+        else
+        {
+            TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_RsdpAddress;
+            Signature = ACPI_SIG_RSDP;
+        }
+
+        /* Now we can get the requested special table */
+
+        Status = OslMapTable (TableAddress, Signature, &MappedTable);
+        if (ACPI_FAILURE (Status))
+        {
+            return (Status);
+        }
+
+        TableLength = ApGetTableLength (MappedTable);
+    }
+    else /* Case for a normal ACPI table */
+    {
+        if (OslCanUseXsdt ())
+        {
+            ItemSize = sizeof (UINT64);
+            TableData = ACPI_CAST8 (Gbl_Xsdt) + sizeof (ACPI_TABLE_HEADER);
+            NumberOfTables =
+                (UINT8) ((Gbl_Xsdt->Header.Length - sizeof (ACPI_TABLE_HEADER))
+                / ItemSize);
+        }
+        else /* Use RSDT if XSDT is not available */
+        {
+            ItemSize = sizeof (UINT32);
+            TableData = ACPI_CAST8 (Gbl_Rsdt) + sizeof (ACPI_TABLE_HEADER);
+            NumberOfTables =
+                (UINT8) ((Gbl_Rsdt->Header.Length - sizeof (ACPI_TABLE_HEADER))
+                / ItemSize);
+        }
+
+        /* Search RSDT/XSDT for the requested table */
+
+        for (i = 0; i < NumberOfTables; ++i, TableData += ItemSize)
+        {
+            if (OslCanUseXsdt ())
+            {
+                TableAddress =
+                    (ACPI_PHYSICAL_ADDRESS) (*ACPI_CAST64 (TableData));
+            }
+            else
+            {
+                TableAddress =
+                    (ACPI_PHYSICAL_ADDRESS) (*ACPI_CAST32 (TableData));
+            }
+
+            /* Skip NULL entries in RSDT/XSDT */
+
+            if (!TableAddress)
+            {
+                continue;
+            }
+
+            Status = OslMapTable (TableAddress, NULL, &MappedTable);
+            if (ACPI_FAILURE (Status))
+            {
+                return (Status);
+            }
+            TableLength = MappedTable->Length;
+
+            /* Does this table match the requested signature? */
+
+            if (!ACPI_COMPARE_NAME (MappedTable->Signature, Signature))
+            {
+                OslUnmapTable (MappedTable);
+                MappedTable = NULL;
+                continue;
+            }
+
+            /* Match table instance (for SSDT/UEFI tables) */
+
+            if (CurrentInstance != Instance)
+            {
+                OslUnmapTable (MappedTable);
+                MappedTable = NULL;
+                CurrentInstance++;
+                continue;
+            }
+
+            break;
+        }
+    }
+
+    if (!MappedTable)
+    {
+        return (AE_LIMIT);
+    }
+
+    if (TableLength == 0)
+    {
+        Status = AE_BAD_HEADER;
+        goto Exit;
+    }
+
+    /* Copy table to local buffer and return it */
+
+    LocalTable = ACPI_ALLOCATE_ZEROED (TableLength);
+    if (!LocalTable)
+    {
+        Status = AE_NO_MEMORY;
+        goto Exit;
+    }
+
+    ACPI_MEMCPY (LocalTable, MappedTable, TableLength);
+    *Address = TableAddress;
+    *Table = LocalTable;
+
+Exit:
+    OslUnmapTable (MappedTable);
+    return (Status);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    OslMapTable
+ *
+ * PARAMETERS:  Address             - Address of the table in memory
+ *              Signature           - Optional ACPI Signature for desired table.
+ *                                    Null terminated 4-character string.
+ *              Table               - Where a pointer to the mapped table is
+ *                                    returned
+ *
+ * RETURN:      Status; Mapped table is returned if AE_OK.
+ *              AE_NOT_FOUND: A valid table was not found at the address
+ *
+ * DESCRIPTION: Map entire ACPI table into caller's address space.
+ *
+ *****************************************************************************/
+
+static ACPI_STATUS
+OslMapTable (
+    ACPI_SIZE               Address,
+    char                    *Signature,
+    ACPI_TABLE_HEADER       **Table)
+{
+    ACPI_TABLE_HEADER       *MappedTable;
+    UINT32                  Length;
+
+
+    if (!Address)
+    {
+        return (AE_BAD_ADDRESS);
+    }
+
+    /*
+     * Map the header so we can get the table length.
+     * Use sizeof (ACPI_TABLE_HEADER) as:
+     * 1. it is bigger than 24 to include RSDP->Length
+     * 2. it is smaller than sizeof (ACPI_TABLE_RSDP)
+     */
+    MappedTable = AcpiOsMapMemory (Address, sizeof (ACPI_TABLE_HEADER));
+    if (!MappedTable)
+    {
+        AcpiLogError ("Could not map table header at 0x%8.8X%8.8X\n",
+            ACPI_FORMAT_UINT64 (Address));
+        return (AE_BAD_ADDRESS);
+    }
+
+    /* If specified, signature must match */
+
+    if (Signature)
+    {
+        if (ACPI_VALIDATE_RSDP_SIG (Signature))
+        {
+            if (!ACPI_VALIDATE_RSDP_SIG (MappedTable->Signature))
+            {
+                AcpiOsUnmapMemory (MappedTable, sizeof (ACPI_TABLE_HEADER));
+                return (AE_BAD_SIGNATURE);
+            }
+        }
+        else if (!ACPI_COMPARE_NAME (Signature, MappedTable->Signature))
+        {
+            AcpiOsUnmapMemory (MappedTable, sizeof (ACPI_TABLE_HEADER));
+            return (AE_BAD_SIGNATURE);
+        }
+    }
+
+    /* Map the entire table */
+
+    Length = ApGetTableLength (MappedTable);
+    AcpiOsUnmapMemory (MappedTable, sizeof (ACPI_TABLE_HEADER));
+    if (Length == 0)
+    {
+        return (AE_BAD_HEADER);
+    }
+
+    MappedTable = AcpiOsMapMemory (Address, Length);
+    if (!MappedTable)
+    {
+        AcpiLogError ("Could not map table at 0x%8.8X%8.8X length %8.8X\n",
+            ACPI_FORMAT_UINT64 (Address), Length);
+        return (AE_INVALID_TABLE_LENGTH);
+    }
+
+    (void) ApIsValidChecksum (MappedTable);
+
+    *Table = MappedTable;
+    return (AE_OK);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    OslUnmapTable
+ *
+ * PARAMETERS:  Table               - A pointer to the mapped table
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Unmap entire ACPI table.
+ *
+ *****************************************************************************/
+
+static void
+OslUnmapTable (
+    ACPI_TABLE_HEADER       *Table)
+{
+    if (Table)
+    {
+        AcpiOsUnmapMemory (Table, ApGetTableLength (Table));
+    }
+}
diff --git a/source/os_specific/service_layers/osefixf.c b/source/os_specific/service_layers/osefixf.c
new file mode 100644
index 000000000000..3f6c5da3353e
--- /dev/null
+++ b/source/os_specific/service_layers/osefixf.c
@@ -0,0 +1,1300 @@
+/******************************************************************************
+ *
+ * Module Name: osefixf - EFI OSL interfaces
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2014, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+
+#include "acpi.h"
+#include "accommon.h"
+#include "acapps.h"
+
+
+/* Local definitions */
+
+#define ACPI_EFI_PRINT_LENGTH   256
+
+
+/* Local definitions */
+
+typedef struct acpi_efi_memory_descriptor {
+    EFI_MEMORY_DESCRIPTOR   *Descriptor;
+    UINTN                   EntryCount;
+    UINTN                   EntrySize;
+    UINTN                   Cookie;
+    UINT32                  Version;
+} ACPI_EFI_MEMORY_DESCRIPTOR;
+
+
+/* Local prototypes */
+
+static void *
+AcpiEfiAllocatePool (
+    ACPI_SIZE               Size);
+
+static ACPI_STATUS
+AcpiEfiArgify (
+    char                    *String,
+    int                     *ArgcPtr,
+    char                    ***ArgvPtr);
+
+static BOOLEAN
+AcpiEfiCompareGuid (
+    EFI_GUID                *Guid1,
+    EFI_GUID                *Guid2);
+
+static ACPI_STATUS
+AcpiEfiConvertArgcv (
+    CHAR16                  *LoadOpt,
+    UINT32                  LoadOptSize,
+    int                     *ArgcPtr,
+    char                    ***ArgvPtr,
+    char                    **BufferPtr);
+
+static ACPI_PHYSICAL_ADDRESS
+AcpiEfiGetRsdpViaGuid (
+    EFI_GUID                *Guid);
+
+static CHAR16 *
+AcpiEfiFlushFile (
+    ACPI_FILE               File,
+    CHAR16                  *Begin,
+    CHAR16                  *End,
+    CHAR16                  *Pos,
+    BOOLEAN                 FlushAll);
+
+static void
+AcpiEfiFreePool (
+    void                    *Mem);
+
+static ACPI_STATUS
+AcpiEfiInitializeMemoryMap (
+    void);
+
+static void
+AcpiEfiTerminateMemoryMap (
+    void);
+
+
+/* Local variables */
+
+static EFI_FILE_HANDLE      AcpiGbl_EfiCurrentVolume = NULL;
+static ACPI_EFI_MEMORY_DESCRIPTOR       AcpiGbl_EfiMemoryMap;
+static BOOLEAN                          AcpiGbl_EfiMemoryInitialized = FALSE;
+static UINTN                            AcpiGbl_EfiPoolAllocation = EfiBootServicesData;
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiEfiGetRsdpViaGuid
+ *
+ * PARAMETERS:  Guid1               - GUID to compare
+ *              Guid2               - GUID to compare
+ *
+ * RETURN:      TRUE if Guid1 == Guid2
+ *
+ * DESCRIPTION: Compares two GUIDs
+ *
+ *****************************************************************************/
+
+static BOOLEAN
+AcpiEfiCompareGuid (
+    EFI_GUID                *Guid1,
+    EFI_GUID                *Guid2)
+{
+    INT32                   *g1;
+    INT32                   *g2;
+    INT32                   r;
+
+
+    g1 = (INT32 *) Guid1;
+    g2 = (INT32 *) Guid2;
+
+    r  = g1[0] - g2[0];
+    r |= g1[1] - g2[1];
+    r |= g1[2] - g2[2];
+    r |= g1[3] - g2[3];
+
+    return (r ? FALSE : TRUE);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiEfiInitializeMemoryMap
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Initialize EFI memory map.
+ *
+ *****************************************************************************/
+
+static ACPI_STATUS
+AcpiEfiInitializeMemoryMap (
+    void)
+{
+    EFI_STATUS              Status;
+    ACPI_EFI_MEMORY_DESCRIPTOR *Map;
+    UINT32                  Length;
+
+
+    if (AcpiGbl_EfiMemoryInitialized)
+    {
+        return (AE_OK);
+    }
+
+    /* Initialize */
+
+    Map = &AcpiGbl_EfiMemoryMap;
+    Length = sizeof (EFI_MEMORY_DESCRIPTOR);
+    Map->Descriptor = NULL;
+    Status = EFI_BUFFER_TOO_SMALL;
+
+    /* Allocation and GetMemoryMap() loop */
+
+    while (!AcpiGbl_EfiMemoryInitialized &&
+           Status == EFI_BUFFER_TOO_SMALL)
+    {
+        Map->Descriptor = AcpiEfiAllocatePool (Length);
+        if (!Map->Descriptor)
+        {
+            return (AE_NO_MEMORY);
+        }
+        Status = uefi_call_wrapper (BS->GetMemoryMap, 5,
+                    &Length, Map->Descriptor,
+                    &Map->Cookie, &Map->EntrySize, &Map->Version);
+        if (!EFI_ERROR (Status))
+        {
+            AcpiGbl_EfiMemoryInitialized = TRUE;
+        }
+        else if (Status == EFI_BUFFER_TOO_SMALL)
+        {
+            AcpiEfiFreePool (Map->Descriptor);
+        }
+    }
+
+    /* Finalize */
+
+    if (!AcpiGbl_EfiMemoryInitialized)
+    {
+        if (Map->Descriptor)
+        {
+            AcpiEfiFreePool (Map->Descriptor);
+            Map->Descriptor = NULL;
+        }
+        return (AE_ERROR);
+    }
+    else
+    {
+        Map->EntryCount = Length / sizeof (EFI_MEMORY_DESCRIPTOR);
+    }
+
+    return (AE_OK);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiEfiTerminateMemoryMap
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Terminate EFI memory map.
+ *
+ *****************************************************************************/
+
+static void
+AcpiEfiTerminateMemoryMap (
+    void)
+{
+
+    if (AcpiGbl_EfiMemoryInitialized)
+    {
+        AcpiEfiFreePool (AcpiGbl_EfiMemoryMap.Descriptor);
+        AcpiGbl_EfiMemoryInitialized = FALSE;
+    }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiEfiGetRsdpViaGuid
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      RSDP address if found
+ *
+ * DESCRIPTION: Find RSDP address via EFI using specified GUID.
+ *
+ *****************************************************************************/
+
+static ACPI_PHYSICAL_ADDRESS
+AcpiEfiGetRsdpViaGuid (
+    EFI_GUID                *Guid)
+{
+    unsigned long           Address = 0;
+    int                     i;
+
+
+    for (i = 0; i < ST->NumberOfTableEntries; i++)
+    {
+        if (AcpiEfiCompareGuid (&ST->ConfigurationTable[i].VendorGuid, Guid))
+        {
+            Address = (ACPI_PHYSICAL_ADDRESS)
+                    ST->ConfigurationTable[i].VendorTable;
+            break;
+        }
+    }
+
+    return ((ACPI_PHYSICAL_ADDRESS) (Address));
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiEfiAllocatePool
+ *
+ * PARAMETERS:  Size                - Amount to allocate, in bytes
+ *
+ * RETURN:      Pointer to the new allocation. Null on error.
+ *
+ * DESCRIPTION: Allocate pool memory.
+ *
+ *****************************************************************************/
+
+static void *
+AcpiEfiAllocatePool (
+    ACPI_SIZE               Size)
+{
+    EFI_STATUS              EfiStatus;
+    void                    *Mem;
+
+
+    EfiStatus = uefi_call_wrapper (BS->AllocatePool, 3,
+        AcpiGbl_EfiPoolAllocation, Size, &Mem);
+    if (EFI_ERROR (EfiStatus))
+    {
+        AcpiLogError ("EFI_BOOT_SERVICES->AllocatePool(EfiLoaderData) failure.\n");
+        return (NULL);
+    }
+
+    return (Mem);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiEfiFreePool
+ *
+ * PARAMETERS:  Mem                 - Pointer to previously allocated memory
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Free memory allocated via AcpiEfiAllocatePool
+ *
+ *****************************************************************************/
+
+static void
+AcpiEfiFreePool (
+    void                    *Mem)
+{
+
+    uefi_call_wrapper (BS->FreePool, 1, Mem);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiOsGetRootPointer
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      RSDP physical address
+ *
+ * DESCRIPTION: Gets the ACPI root pointer (RSDP)
+ *
+ *****************************************************************************/
+
+ACPI_PHYSICAL_ADDRESS
+AcpiOsGetRootPointer (
+    void)
+{
+    ACPI_PHYSICAL_ADDRESS   Address;
+    EFI_GUID                Guid10 = ACPI_TABLE_GUID;
+    EFI_GUID                Guid20 = ACPI_20_TABLE_GUID;
+
+
+    Address = AcpiEfiGetRsdpViaGuid (&Guid20);
+    if (!Address)
+    {
+        Address = AcpiEfiGetRsdpViaGuid (&Guid10);
+    }
+
+    return (Address);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiOsMapMemory
+ *
+ * PARAMETERS:  where               - Physical address of memory to be mapped
+ *              length              - How much memory to map
+ *
+ * RETURN:      Pointer to mapped memory. Null on error.
+ *
+ * DESCRIPTION: Map physical memory into caller's address space
+ *
+ *****************************************************************************/
+
+void *
+AcpiOsMapMemory (
+    ACPI_PHYSICAL_ADDRESS   where,
+    ACPI_SIZE               length)
+{
+    UINTN                   i;
+    EFI_MEMORY_DESCRIPTOR   *p;
+    UINT64                  Size;
+    EFI_PHYSICAL_ADDRESS    End;
+
+
+    for (i = 0, p = AcpiGbl_EfiMemoryMap.Descriptor;
+         i < AcpiGbl_EfiMemoryMap.EntryCount;
+         i++, p = ACPI_ADD_PTR (EFI_MEMORY_DESCRIPTOR, p, AcpiGbl_EfiMemoryMap.EntrySize))
+    {
+        Size = p->NumberOfPages << EFI_PAGE_SHIFT;
+        End = p->PhysicalStart + Size;
+
+        if (!(p->Attribute & EFI_MEMORY_RUNTIME) || !p->VirtualStart)
+        {
+            continue;
+        }
+
+        if (where >= p->PhysicalStart && where < End)
+        {
+            where += p->VirtualStart - p->PhysicalStart;
+            break;
+        }
+    }
+
+    /* Default to use the physical address */
+
+    return (ACPI_TO_POINTER ((ACPI_SIZE) where));
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiOsUnmapMemory
+ *
+ * PARAMETERS:  where               - Logical address of memory to be unmapped
+ *              length              - How much memory to unmap
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Delete a previously created mapping. Where and Length must
+ *              correspond to a previous mapping exactly.
+ *
+ *****************************************************************************/
+
+void
+AcpiOsUnmapMemory (
+    void                    *where,
+    ACPI_SIZE               length)
+{
+
+    return;
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    Spinlock interfaces
+ *
+ * DESCRIPTION: No-op on single threaded BIOS
+ *
+ *****************************************************************************/
+
+ACPI_STATUS
+AcpiOsCreateLock (
+    ACPI_SPINLOCK           *OutHandle)
+{
+    return (AE_OK);
+}
+
+void
+AcpiOsDeleteLock (
+    ACPI_SPINLOCK           Handle)
+{
+}
+
+ACPI_CPU_FLAGS
+AcpiOsAcquireLock (
+    ACPI_SPINLOCK           Handle)
+{
+    return (0);
+}
+
+void
+AcpiOsReleaseLock (
+    ACPI_SPINLOCK           Handle,
+    ACPI_CPU_FLAGS          Flags)
+{
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiOsAllocate
+ *
+ * PARAMETERS:  Size                - Amount to allocate, in bytes
+ *
+ * RETURN:      Pointer to the new allocation. Null on error.
+ *
+ * DESCRIPTION: Allocate memory. Algorithm is dependent on the OS.
+ *
+ *****************************************************************************/
+
+void *
+AcpiOsAllocate (
+    ACPI_SIZE               Size)
+{
+    EFI_STATUS              EfiStatus;
+    void                    *Mem;
+
+
+    EfiStatus = uefi_call_wrapper (BS->AllocatePool, 3,
+        EfiLoaderData, Size, &Mem);
+    if (EFI_ERROR (EfiStatus))
+    {
+        AcpiLogError ("EFI_BOOT_SERVICES->AllocatePool(EfiLoaderData) failure.\n");
+        return (NULL);
+    }
+
+    return (Mem);
+}
+
+
+#ifdef USE_NATIVE_ALLOCATE_ZEROED
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiOsAllocateZeroed
+ *
+ * PARAMETERS:  Size                - Amount to allocate, in bytes
+ *
+ * RETURN:      Pointer to the new allocation. Null on error.
+ *
+ * DESCRIPTION: Allocate and zero memory. Algorithm is dependent on the OS.
+ *
+ *****************************************************************************/
+
+void *
+AcpiOsAllocateZeroed (
+    ACPI_SIZE               Size)
+{
+    void                    *Mem;
+
+
+    Mem = AcpiOsAllocate (Size);
+    if (Mem)
+    {
+        ACPI_MEMSET (Mem, 0, Size);
+    }
+
+    return (Mem);
+}
+#endif
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiOsFree
+ *
+ * PARAMETERS:  Mem                 - Pointer to previously allocated memory
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Free memory allocated via AcpiOsAllocate
+ *
+ *****************************************************************************/
+
+void
+AcpiOsFree (
+    void                    *Mem)
+{
+
+    uefi_call_wrapper (BS->FreePool, 1, Mem);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiOsOpenFile
+ *
+ * PARAMETERS:  Path                - File path
+ *              Modes               - File operation type
+ *
+ * RETURN:      File descriptor
+ *
+ * DESCRIPTION: Open a file for reading (ACPI_FILE_READING) or/and writing
+ *              (ACPI_FILE_WRITING).
+ *
+ ******************************************************************************/
+
+ACPI_FILE
+AcpiOsOpenFile (
+    const char              *Path,
+    UINT8                   Modes)
+{
+    EFI_STATUS              EfiStatus = EFI_SUCCESS;
+    UINT64                  OpenModes;
+    EFI_FILE_HANDLE         EfiFile = NULL;
+    CHAR16                  *Path16 = NULL;
+    CHAR16                  *Pos16;
+    const char              *Pos;
+    INTN                    Count, i;
+
+
+    if (!Path)
+    {
+        return (NULL);
+    }
+
+    /* Convert modes */
+
+    OpenModes = EFI_FILE_MODE_READ;
+    if (Modes & ACPI_FILE_WRITING)
+    {
+        OpenModes |= (EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE);
+    }
+
+    /* Allocate path buffer */
+
+    Count = ACPI_STRLEN (Path);
+    Path16 = ACPI_ALLOCATE_ZEROED ((Count + 1) * sizeof (CHAR16));
+    if (!Path16)
+    {
+        EfiStatus = EFI_BAD_BUFFER_SIZE;
+        goto ErrorExit;
+    }
+    Pos = Path;
+    Pos16 = Path16;
+    while (*Pos == '/' || *Pos == '\\')
+    {
+        Pos++;
+        Count--;
+    }
+    for (i = 0; i < Count; i++)
+    {
+        if (*Pos == '/')
+        {
+            *Pos16++ = '\\';
+            Pos++;
+        }
+        else
+        {
+            *Pos16++ = *Pos++;
+        }
+    }
+    *Pos16 = '\0';
+
+    EfiStatus = uefi_call_wrapper (AcpiGbl_EfiCurrentVolume->Open, 5,
+        AcpiGbl_EfiCurrentVolume, &EfiFile, Path16, OpenModes, 0);
+    if (EFI_ERROR (EfiStatus))
+    {
+        AcpiLogError ("EFI_FILE_HANDLE->Open() failure.\n");
+        goto ErrorExit;
+    }
+
+ErrorExit:
+
+    if (Path16)
+    {
+        ACPI_FREE (Path16);
+    }
+
+    return ((ACPI_FILE) EfiFile);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiOsCloseFile
+ *
+ * PARAMETERS:  File                - File descriptor
+ *
+ * RETURN:      None.
+ *
+ * DESCRIPTION: Close a file.
+ *
+ ******************************************************************************/
+
+void
+AcpiOsCloseFile (
+    ACPI_FILE               File)
+{
+    EFI_FILE_HANDLE         EfiFile;
+
+
+    if (File == ACPI_FILE_OUT ||
+        File == ACPI_FILE_ERR)
+    {
+        return;
+    }
+    EfiFile = (EFI_FILE_HANDLE) File;
+    (void) uefi_call_wrapper (AcpiGbl_EfiCurrentVolume->Close, 1, EfiFile);
+
+    return;
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiOsReadFile
+ *
+ * PARAMETERS:  File                - File descriptor
+ *              Buffer              - Data buffer
+ *              Size                - Data block size
+ *              Count               - Number of data blocks
+ *
+ * RETURN:      Size of successfully read buffer
+ *
+ * DESCRIPTION: Read from a file.
+ *
+ ******************************************************************************/
+
+int
+AcpiOsReadFile (
+    ACPI_FILE               File,
+    void                    *Buffer,
+    ACPI_SIZE               Size,
+    ACPI_SIZE               Count)
+{
+    int                     Length = -1;
+    EFI_FILE_HANDLE         EfiFile;
+    UINTN                   ReadSize;
+    EFI_STATUS              EfiStatus;
+
+
+    if (File == ACPI_FILE_OUT ||
+        File == ACPI_FILE_ERR)
+    {
+    }
+    else
+    {
+        EfiFile = (EFI_FILE_HANDLE) File;
+        if (!EfiFile)
+        {
+            goto ErrorExit;
+        }
+        ReadSize = Size * Count;
+
+        EfiStatus = uefi_call_wrapper (AcpiGbl_EfiCurrentVolume->Read, 3,
+            EfiFile, &ReadSize, Buffer);
+        if (EFI_ERROR (EfiStatus))
+        {
+            AcpiLogError ("EFI_FILE_HANDLE->Read() failure.\n");
+            goto ErrorExit;
+        }
+        Length = ReadSize;
+    }
+
+ErrorExit:
+
+    return (Length);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiEfiFlushFile
+ *
+ * PARAMETERS:  File                - File descriptor
+ *              Begin               - String with boundary
+ *              End                 - Boundary of the string
+ *              Pos                 - Current position
+ *              FlushAll            - Whether checking boundary before flushing
+ *
+ * RETURN:      Updated position
+ *
+ * DESCRIPTION: Flush cached buffer to the file.
+ *
+ ******************************************************************************/
+
+static CHAR16 *
+AcpiEfiFlushFile (
+    ACPI_FILE               File,
+    CHAR16                  *Begin,
+    CHAR16                  *End,
+    CHAR16                  *Pos,
+    BOOLEAN                 FlushAll)
+{
+
+    if (FlushAll || Pos >= (End - 1))
+    {
+        *Pos = 0;
+        uefi_call_wrapper (File->OutputString, 2, File, Begin);
+        Pos = Begin;
+    }
+
+    return (Pos);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiOsWriteFile
+ *
+ * PARAMETERS:  File                - File descriptor
+ *              Buffer              - Data buffer
+ *              Size                - Data block size
+ *              Count               - Number of data blocks
+ *
+ * RETURN:      Size of successfully written buffer
+ *
+ * DESCRIPTION: Write to a file.
+ *
+ ******************************************************************************/
+
+int
+AcpiOsWriteFile (
+    ACPI_FILE               File,
+    void                    *Buffer,
+    ACPI_SIZE               Size,
+    ACPI_SIZE               Count)
+{
+    int                     Length = -1;
+    CHAR16                  String[ACPI_EFI_PRINT_LENGTH];
+    const char              *Ascii;
+    CHAR16                  *End;
+    CHAR16                  *Pos;
+    int                     i, j;
+    EFI_FILE_HANDLE         EfiFile;
+    UINTN                   WriteSize;
+    EFI_STATUS              EfiStatus;
+
+
+    if (File == ACPI_FILE_OUT ||
+        File == ACPI_FILE_ERR)
+    {
+        Pos = String;
+        End = String + ACPI_EFI_PRINT_LENGTH - 1;
+        Ascii = ACPI_CAST_PTR (const char, Buffer);
+        Length = 0;
+
+        for (j = 0; j < Count; j++)
+        {
+            for (i = 0; i < Size; i++)
+            {
+                if (*Ascii == '\n')
+                {
+                    *Pos++ = '\r';
+                    Pos = AcpiEfiFlushFile (File, String,
+                            End, Pos, FALSE);
+                }
+                *Pos++ = *Ascii++;
+                Length++;
+                Pos = AcpiEfiFlushFile (File, String,
+                        End, Pos, FALSE);
+            }
+        }
+        Pos = AcpiEfiFlushFile (File, String, End, Pos, TRUE);
+    }
+    else
+    {
+        EfiFile = (EFI_FILE_HANDLE) File;
+        if (!EfiFile)
+        {
+            goto ErrorExit;
+        }
+        WriteSize = Size * Count;
+
+        EfiStatus = uefi_call_wrapper (AcpiGbl_EfiCurrentVolume->Write, 3,
+            EfiFile, &WriteSize, Buffer);
+        if (EFI_ERROR (EfiStatus))
+        {
+            AcpiLogError ("EFI_FILE_HANDLE->Write() failure.\n");
+            goto ErrorExit;
+        }
+        Length = WriteSize;
+    }
+
+ErrorExit:
+
+    return (Length);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiOsGetFileOffset
+ *
+ * PARAMETERS:  File                - File descriptor
+ *
+ * RETURN:      Size of current position
+ *
+ * DESCRIPTION: Get current file offset.
+ *
+ ******************************************************************************/
+
+long
+AcpiOsGetFileOffset (
+    ACPI_FILE               File)
+{
+    long                    Offset = -1;
+
+
+    return (Offset);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiOsSetFileOffset
+ *
+ * PARAMETERS:  File                - File descriptor
+ *              Offset              - File offset
+ *              From                - From begin/end of file
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Set current file offset.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiOsSetFileOffset (
+    ACPI_FILE               File,
+    long                    Offset,
+    UINT8                   From)
+{
+
+    return (AE_SUPPORT);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiOsPrintf
+ *
+ * PARAMETERS:  Format, ...         - Standard printf format
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Formatted output.
+ *
+ *****************************************************************************/
+
+void ACPI_INTERNAL_VAR_XFACE
+AcpiOsPrintf (
+    const char              *Format,
+    ...)
+{
+    va_list                 Args;
+
+
+    va_start (Args, Format);
+    AcpiOsVprintf (Format, Args);
+    va_end (Args);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiOsVprintf
+ *
+ * PARAMETERS:  Format              - Standard printf format
+ *              Args                - Argument list
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Formatted output with arguments list pointer.
+ *
+ *****************************************************************************/
+
+void
+AcpiOsVprintf (
+    const char              *Format,
+    va_list                 Args)
+{
+
+    (void) AcpiUtFileVprintf (ACPI_FILE_OUT, Format, Args);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiOsInitialize
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Initialize this module.
+ *
+ *****************************************************************************/
+
+ACPI_STATUS
+AcpiOsInitialize (
+    void)
+{
+
+    return (AE_OK);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiEfiArgify
+ *
+ * PARAMETERS:  String              - Pointer to command line argument strings
+ *                                    which are seperated with spaces
+ *              ArgcPtr             - Return number of the arguments
+ *              ArgvPtr             - Return vector of the arguments
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Convert EFI arguments into C arguments.
+ *
+ *****************************************************************************/
+
+static ACPI_STATUS
+AcpiEfiArgify (
+    char                    *String,
+    int                     *ArgcPtr,
+    char                    ***ArgvPtr)
+{
+    char                    *CopyBuffer;
+    int                     MaxArgc = *ArgcPtr;
+    int                     Argc = 0;
+    char                    **Argv = *ArgvPtr;
+    char                    *Arg;
+    BOOLEAN                 IsSingleQuote = FALSE;
+    BOOLEAN                 IsDoubleQuote = FALSE;
+    BOOLEAN                 IsEscape = FALSE;
+
+
+    if (String == NULL)
+    {
+        return (AE_BAD_PARAMETER);
+    }
+
+    CopyBuffer = String;
+
+    while (*String != '\0')
+    {
+        while (ACPI_IS_SPACE (*String))
+        {
+            *String++ = '\0';
+        }
+        Arg = CopyBuffer;
+        while (*String != '\0')
+        {
+            if (ACPI_IS_SPACE (*String) &&
+                !IsSingleQuote && !IsDoubleQuote && !IsEscape)
+            {
+                *Arg++ = '\0';
+                String++;
+                break;
+            }
+            if (IsEscape)
+            {
+                IsEscape = FALSE;
+                *Arg++ = *String;
+            }
+            else if (*String == '\\')
+            {
+                IsEscape = TRUE;
+            }
+            else if (IsSingleQuote)
+            {
+                if (*String == '\'')
+                {
+                    IsSingleQuote = FALSE;
+                    *Arg++ = '\0';
+                }
+                else
+                {
+                    *Arg++ = *String;
+                }
+            }
+            else if (IsDoubleQuote)
+            {
+                if (*String == '"')
+                {
+                    IsDoubleQuote = FALSE;
+                    *Arg = '\0';
+                }
+                else
+                {
+                    *Arg++ = *String;
+                }
+            }
+            else
+            {
+                if (*String == '\'')
+                {
+                    IsSingleQuote = TRUE;
+                }
+                else if (*String == '"')
+                {
+                    IsDoubleQuote = TRUE;
+                }
+                else
+                {
+                    *Arg++ = *String;
+                }
+            }
+            String++;
+        }
+        if (Argv && Argc < MaxArgc)
+        {
+            Argv[Argc] = CopyBuffer;
+        }
+        Argc++;
+        CopyBuffer = Arg;
+    }
+    if (Argv && Argc < MaxArgc)
+    {
+        Argv[Argc] = NULL;
+    }
+
+    *ArgcPtr = Argc;
+    *ArgvPtr = Argv;
+
+    return ((MaxArgc < Argc) ? AE_NO_MEMORY : AE_OK);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiEfiConvertArgcv
+ *
+ * PARAMETERS:  LoadOptions         - Pointer to the EFI options buffer, which
+ *                                    is NULL terminated
+ *              LoadOptionsSize     - Size of the EFI options buffer
+ *              ArgcPtr             - Return number of the arguments
+ *              ArgvPtr             - Return vector of the arguments
+ *              BufferPtr           - Buffer to contain the argument strings
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Convert EFI arguments into C arguments.
+ *
+ *****************************************************************************/
+
+static ACPI_STATUS
+AcpiEfiConvertArgcv (
+    CHAR16                  *LoadOptions,
+    UINT32                  LoadOptionsSize,
+    int                     *ArgcPtr,
+    char                    ***ArgvPtr,
+    char                    **BufferPtr)
+{
+    ACPI_STATUS             Status = AE_OK;
+    UINT32                  Count = LoadOptionsSize / sizeof (CHAR16);
+    UINT32                  i;
+    CHAR16                  *From;
+    char                    *To;
+    int                     Argc = 0;
+    char                    **Argv = NULL;
+    char                    *Buffer;
+
+
+    /* Prepare a buffer to contain the argument strings */
+
+    Buffer = ACPI_ALLOCATE_ZEROED (Count);
+    if (!Buffer)
+    {
+        Status = AE_NO_MEMORY;
+        goto ErrorExit;
+    }
+
+TryAgain:
+
+    /* Extend the argument vector */
+
+    if (Argv)
+    {
+        ACPI_FREE (Argv);
+        Argv = NULL;
+    }
+    if (Argc > 0)
+    {
+        Argv = ACPI_ALLOCATE_ZEROED (sizeof (char *) * (Argc + 1));
+        if (!Argv)
+        {
+            Status = AE_NO_MEMORY;
+            goto ErrorExit;
+        }
+    }
+
+    /*
+     * Note: As AcpiEfiArgify() will modify the content of the buffer, so
+     *       we need to restore it each time before invoking
+     *       AcpiEfiArgify().
+     */
+    From = LoadOptions;
+    To = ACPI_CAST_PTR (char, Buffer);
+    for (i = 0; i < Count; i++)
+    {
+        *To++ = (char) *From++;
+    }
+
+    /*
+     * The "Buffer" will contain NULL terminated strings after invoking
+     * AcpiEfiArgify(). The number of the strings are saved in Argc and the
+     * pointers of the strings are saved in Argv.
+     */
+    Status = AcpiEfiArgify (Buffer, &Argc, &Argv);
+    if (ACPI_FAILURE (Status))
+    {
+        if (Status == AE_NO_MEMORY)
+        {
+            goto TryAgain;
+        }
+    }
+
+ErrorExit:
+
+    if (ACPI_FAILURE (Status))
+    {
+        ACPI_FREE (Buffer);
+        ACPI_FREE (Argv);
+    }
+    else
+    {
+        *ArgcPtr = Argc;
+        *ArgvPtr = Argv;
+        *BufferPtr = Buffer;
+    }
+    return (Status);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION:    efi_main
+ *
+ * PARAMETERS:  Image               - EFI image handle
+ *              SystemTab           - EFI system table
+ *
+ * RETURN:      EFI Status
+ *
+ * DESCRIPTION: Entry point of EFI executable
+ *
+ *****************************************************************************/
+
+EFI_STATUS
+efi_main (
+    EFI_HANDLE              Image,
+    EFI_SYSTEM_TABLE        *SystemTab)
+{
+    EFI_LOADED_IMAGE        *Info;
+    EFI_STATUS              EfiStatus = EFI_SUCCESS;
+    ACPI_STATUS             Status;
+    int                     argc;
+    char                    **argv = NULL;
+    char                    *OptBuffer = NULL;
+    EFI_FILE_IO_INTERFACE   *Volume = NULL;
+
+
+    /* Initialize EFI library */
+
+    InitializeLib (Image, SystemTab);
+
+    /* Retrieve image information */
+
+    EfiStatus = uefi_call_wrapper (BS->HandleProtocol, 3,
+        Image, &LoadedImageProtocol, ACPI_CAST_PTR (VOID, &Info));
+    if (EFI_ERROR (EfiStatus))
+    {
+        AcpiLogError ("EFI_BOOT_SERVICES->HandleProtocol(LoadedImageProtocol) failure.\n");
+        return (EfiStatus);
+    }
+    AcpiGbl_EfiPoolAllocation = Info->ImageDataType;
+    EfiStatus = uefi_call_wrapper (BS->HandleProtocol, 3,
+        Info->DeviceHandle, &FileSystemProtocol, (void **) &Volume);
+    if (EFI_ERROR (EfiStatus))
+    {
+        AcpiLogError ("EFI_BOOT_SERVICES->HandleProtocol(FileSystemProtocol) failure.\n");
+        return (EfiStatus);
+    }
+    EfiStatus = uefi_call_wrapper (Volume->OpenVolume, 2,
+        Volume, &AcpiGbl_EfiCurrentVolume);
+    if (EFI_ERROR (EfiStatus))
+    {
+        AcpiLogError ("EFI_FILE_IO_INTERFACE->OpenVolume() failure.\n");
+        return (EfiStatus);
+    }
+    Status = AcpiEfiInitializeMemoryMap ();
+    if (ACPI_FAILURE (Status))
+    {
+        EfiStatus = EFI_DEVICE_ERROR;
+        goto ErrorAlloc;
+    }
+
+    Status = AcpiEfiConvertArgcv (Info->LoadOptions,
+        Info->LoadOptionsSize, &argc, &argv, &OptBuffer);
+    if (ACPI_FAILURE (Status))
+    {
+        EfiStatus = EFI_DEVICE_ERROR;
+        goto ErrorAlloc;
+    }
+
+    acpi_main (argc, argv);
+
+ErrorAlloc:
+
+    if (argv)
+    {
+        ACPI_FREE (argv);
+    }
+    if (OptBuffer)
+    {
+        ACPI_FREE (OptBuffer);
+    }
+    AcpiEfiTerminateMemoryMap ();
+
+    return (EfiStatus);
+}
diff --git a/source/os_specific/service_layers/oslibcfs.c b/source/os_specific/service_layers/oslibcfs.c
new file mode 100644
index 000000000000..3bb55bb94cc0
--- /dev/null
+++ b/source/os_specific/service_layers/oslibcfs.c
@@ -0,0 +1,251 @@
+/******************************************************************************
+ *
+ * Module Name: oslibcfs - C library OSL for file IO
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2014, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include "acpi.h"
+#include <stdio.h>
+#include <stdarg.h>
+
+#define _COMPONENT          ACPI_OS_SERVICES
+        ACPI_MODULE_NAME    ("oslibcfs")
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiOsOpenFile
+ *
+ * PARAMETERS:  Path                - File path
+ *              Modes               - File operation type
+ *
+ * RETURN:      File descriptor.
+ *
+ * DESCRIPTION: Open a file for reading (ACPI_FILE_READING) or/and writing
+ *              (ACPI_FILE_WRITING).
+ *
+ ******************************************************************************/
+
+ACPI_FILE
+AcpiOsOpenFile (
+    const char              *Path,
+    UINT8                   Modes)
+{
+    ACPI_FILE               File;
+    char                    ModesStr[4];
+    UINT32                  i = 0;
+
+    if (Modes & ACPI_FILE_READING)
+    {
+        ModesStr[i++] = 'r';
+    }
+    if (Modes & ACPI_FILE_WRITING)
+    {
+        ModesStr[i++] = 'w';
+    }
+    if (Modes & ACPI_FILE_BINARY)
+    {
+        ModesStr[i++] = 'b';
+    }
+    ModesStr[i++] = '\0';
+
+    File = fopen (Path, ModesStr);
+    if (!File)
+    {
+        perror ("Could not open file");
+    }
+
+    return (File);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiOsCloseFile
+ *
+ * PARAMETERS:  File                - File descriptor
+ *
+ * RETURN:      None.
+ *
+ * DESCRIPTION: Close a file.
+ *
+ ******************************************************************************/
+
+void
+AcpiOsCloseFile (
+    ACPI_FILE               File)
+{
+    fclose (File);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiOsReadFile
+ *
+ * PARAMETERS:  File                - File descriptor
+ *              Buffer              - Data buffer
+ *              Size                - Data block size
+ *              Count               - Number of data blocks
+ *
+ * RETURN:      Size of successfully read buffer.
+ *
+ * DESCRIPTION: Read a file.
+ *
+ ******************************************************************************/
+
+int
+AcpiOsReadFile (
+    ACPI_FILE               File,
+    void                    *Buffer,
+    ACPI_SIZE               Size,
+    ACPI_SIZE               Count)
+{
+    int                     Length;
+
+    Length = fread (Buffer, Size, Count, File);
+    if (Length < 0)
+    {
+        perror ("Error reading file");
+    }
+
+    return (Length);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiOsWriteFile
+ *
+ * PARAMETERS:  File                - File descriptor
+ *              Buffer              - Data buffer
+ *              Size                - Data block size
+ *              Count               - Number of data blocks
+ *
+ * RETURN:      Size of successfully written buffer.
+ *
+ * DESCRIPTION: Write a file.
+ *
+ ******************************************************************************/
+
+int
+AcpiOsWriteFile (
+    ACPI_FILE               File,
+    void                    *Buffer,
+    ACPI_SIZE               Size,
+    ACPI_SIZE               Count)
+{
+    int                     Length;
+
+    Length = fwrite (Buffer, Size, Count, File);
+    if (Length < 0)
+    {
+        perror ("Error writing file");
+    }
+
+    return (Length);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiOsGetFileOffset
+ *
+ * PARAMETERS:  File                - File descriptor
+ *
+ * RETURN:      Size of current position.
+ *
+ * DESCRIPTION: Get current file offset.
+ *
+ ******************************************************************************/
+
+long
+AcpiOsGetFileOffset (
+    ACPI_FILE               File)
+{
+    long                    Offset;
+
+    Offset = ftell (File);
+
+    return (Offset);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiOsSetFileOffset
+ *
+ * PARAMETERS:  File                - File descriptor
+ *              Offset              - File offset
+ *              From                - From begin/end of file
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Set current file offset.
+ *
+ ******************************************************************************/
+
+ACPI_STATUS
+AcpiOsSetFileOffset (
+    ACPI_FILE               File,
+    long                    Offset,
+    UINT8                   From)
+{
+    int                     Ret = 0;
+
+
+    if (From == ACPI_FILE_BEGIN)
+    {
+        Ret = fseek (File, Offset, SEEK_SET);
+    }
+    if (From == ACPI_FILE_END)
+    {
+        Ret = fseek (File, Offset, SEEK_END);
+    }
+
+    if (Ret < 0)
+    {
+        return (AE_ERROR);
+    }
+    else
+    {
+        return (AE_OK);
+    }
+}
diff --git a/source/os_specific/service_layers/oslinuxtbl.c b/source/os_specific/service_layers/oslinuxtbl.c
index aee929e0ee91..aae93325add2 100644
--- a/source/os_specific/service_layers/oslinuxtbl.c
+++ b/source/os_specific/service_layers/oslinuxtbl.c
@@ -98,6 +98,11 @@ OslUnmapTable (
     ACPI_TABLE_HEADER       *Table);
 
 static ACPI_PHYSICAL_ADDRESS
+OslFindRsdpViaEfiByKeyword (
+    FILE                    *File,
+    const char              *Keyword);
+
+static ACPI_PHYSICAL_ADDRESS
 OslFindRsdpViaEfi (
     void);
 
@@ -490,6 +495,44 @@ AcpiOsGetTableByIndex (
 
 /******************************************************************************
  *
+ * FUNCTION:    OslFindRsdpViaEfiByKeyword
+ *
+ * PARAMETERS:  Keyword         - Character string indicating ACPI GUID version
+ *                                in the EFI table
+ *
+ * RETURN:      RSDP address if found
+ *
+ * DESCRIPTION: Find RSDP address via EFI using keyword indicating the ACPI
+ *              GUID version.
+ *
+ *****************************************************************************/
+
+static ACPI_PHYSICAL_ADDRESS
+OslFindRsdpViaEfiByKeyword (
+    FILE                    *File,
+    const char              *Keyword)
+{
+    char                    Buffer[80];
+    unsigned long long      Address = 0;
+    char                    Format[32];
+
+
+    snprintf (Format, 32, "%s=%s", Keyword, "%llx");
+    fseek (File, 0, SEEK_SET);
+    while (fgets (Buffer, 80, File))
+    {
+        if (sscanf (Buffer, Format, &Address) == 1)
+        {
+            break;
+        }
+    }
+
+    return ((ACPI_PHYSICAL_ADDRESS) (Address));
+}
+
+
+/******************************************************************************
+ *
  * FUNCTION:    OslFindRsdpViaEfi
  *
  * PARAMETERS:  None
@@ -505,24 +548,21 @@ OslFindRsdpViaEfi (
     void)
 {
     FILE                    *File;
-    char                    Buffer[80];
-    unsigned long           Address = 0;
+    ACPI_PHYSICAL_ADDRESS   Address = 0;
 
 
     File = fopen (EFI_SYSTAB, "r");
     if (File)
     {
-        while (fgets (Buffer, 80, File))
+        Address = OslFindRsdpViaEfiByKeyword (File, "ACPI20");
+        if (!Address)
         {
-            if (sscanf (Buffer, "ACPI20=0x%lx", &Address) == 1)
-            {
-                break;
-            }
+            Address = OslFindRsdpViaEfiByKeyword (File, "ACPI");
         }
         fclose (File);
     }
 
-    return ((ACPI_PHYSICAL_ADDRESS) (Address));
+    return (Address);
 }
 
 
@@ -907,6 +947,11 @@ OslGetBiosTable (
         ACPI_COMPARE_NAME (Signature, ACPI_SIG_DSDT) ||
         ACPI_COMPARE_NAME (Signature, ACPI_SIG_FACS))
     {
+        if (Instance > 0)
+        {
+            return (AE_LIMIT);
+        }
+
         /*
          * Get the appropriate address, either 32-bit or 64-bit. Be very
          * careful about the FADT length and validate table addresses.
diff --git a/source/os_specific/service_layers/osunixxf.c b/source/os_specific/service_layers/osunixxf.c
index dd151eee9551..eb088b9dd128 100644
--- a/source/os_specific/service_layers/osunixxf.c
+++ b/source/os_specific/service_layers/osunixxf.c
@@ -65,16 +65,11 @@
         ACPI_MODULE_NAME    ("osunixxf")
 
 
-FILE                           *AcpiGbl_OutputFile;
 BOOLEAN                        AcpiGbl_DebugTimeout = FALSE;
 
 
 /* Upcalls to AcpiExec */
 
-ACPI_PHYSICAL_ADDRESS
-AeLocalGetRootPointer (
-    void);
-
 void
 AeTableOverride (
     ACPI_TABLE_HEADER       *ExistingTable,
@@ -214,10 +209,19 @@ ACPI_STATUS
 AcpiOsInitialize (
     void)
 {
+    ACPI_STATUS            Status;
+
 
     AcpiGbl_OutputFile = stdout;
 
     OsEnterLineEditMode ();
+
+    Status = AcpiOsCreateLock (&AcpiGbl_PrintLock);
+    if (ACPI_FAILURE (Status))
+    {
+        return (Status);
+    }
+
     return (AE_OK);
 }
 
@@ -231,6 +235,7 @@ AcpiOsTerminate (
 }
 
 
+#ifndef ACPI_USE_NATIVE_RSDP_POINTER
 /******************************************************************************
  *
  * FUNCTION:    AcpiOsGetRootPointer
@@ -248,8 +253,9 @@ AcpiOsGetRootPointer (
     void)
 {
 
-    return (AeLocalGetRootPointer ());
+    return (0);
 }
+#endif
 
 
 /******************************************************************************
@@ -548,6 +554,7 @@ AcpiOsGetLine (
 #endif
 
 
+#ifndef ACPI_USE_NATIVE_MEMORY_MAPPING
 /******************************************************************************
  *
  * FUNCTION:    AcpiOsMapMemory
@@ -593,6 +600,7 @@ AcpiOsUnmapMemory (
 
     return;
 }
+#endif
 
 
 /******************************************************************************
@@ -619,6 +627,32 @@ AcpiOsAllocate (
 }
 
 
+#ifdef USE_NATIVE_ALLOCATE_ZEROED
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiOsAllocateZeroed
+ *
+ * PARAMETERS:  Size                - Amount to allocate, in bytes
+ *
+ * RETURN:      Pointer to the new allocation. Null on error.
+ *
+ * DESCRIPTION: Allocate and zero memory. Algorithm is dependent on the OS.
+ *
+ *****************************************************************************/
+
+void *
+AcpiOsAllocateZeroed (
+    ACPI_SIZE               size)
+{
+    void                    *Mem;
+
+
+    Mem = (void *) calloc (1, (size_t) size);
+    return (Mem);
+}
+#endif
+
+
 /******************************************************************************
  *
  * FUNCTION:    AcpiOsFree
@@ -1454,6 +1488,26 @@ AcpiOsExecute (
     return (0);
 }
 
+#else /* ACPI_SINGLE_THREADED */
+ACPI_THREAD_ID
+AcpiOsGetThreadId (
+    void)
+{
+    return (1);
+}
+
+ACPI_STATUS
+AcpiOsExecute (
+    ACPI_EXECUTE_TYPE       Type,
+    ACPI_OSD_EXEC_CALLBACK  Function,
+    void                    *Context)
+{
+
+    Function (Context);
+
+    return (AE_OK);
+}
+
 #endif /* ACPI_SINGLE_THREADED */
 
 
diff --git a/source/os_specific/service_layers/oswinxf.c b/source/os_specific/service_layers/oswinxf.c
index 667a9f905333..140bfdbb880e 100644
--- a/source/os_specific/service_layers/oswinxf.c
+++ b/source/os_specific/service_layers/oswinxf.c
@@ -64,7 +64,6 @@
         ACPI_MODULE_NAME    ("oswinxf")
 
 
-FILE                        *AcpiGbl_OutputFile;
 UINT64                      TimerFrequency;
 char                        TableName[ACPI_NAME_SIZE + 1];
 
@@ -73,10 +72,6 @@ char                        TableName[ACPI_NAME_SIZE + 1];
 
 /* Upcalls to AcpiExec application */
 
-ACPI_PHYSICAL_ADDRESS
-AeLocalGetRootPointer (
-    void);
-
 void
 AeTableOverride (
     ACPI_TABLE_HEADER       *ExistingTable,
@@ -143,6 +138,7 @@ ACPI_STATUS
 AcpiOsInitialize (
     void)
 {
+    ACPI_STATUS             Status;
     LARGE_INTEGER           LocalTimerFrequency;
 
 
@@ -164,10 +160,17 @@ AcpiOsInitialize (
         TimerFrequency = LocalTimerFrequency.QuadPart;
     }
 
+    Status = AcpiOsCreateLock (&AcpiGbl_PrintLock);
+    if (ACPI_FAILURE (Status))
+    {
+        return (Status);
+    }
+
     return (AE_OK);
 }
 
 
+#ifndef ACPI_USE_NATIVE_RSDP_POINTER
 /******************************************************************************
  *
  * FUNCTION:    AcpiOsGetRootPointer
@@ -185,8 +188,9 @@ AcpiOsGetRootPointer (
     void)
 {
 
-    return (AeLocalGetRootPointer ());
+    return (0);
 }
+#endif
 
 
 /******************************************************************************
@@ -554,6 +558,7 @@ AcpiOsGetLine (
 }
 
 
+#ifndef ACPI_USE_NATIVE_MEMORY_MAPPING
 /******************************************************************************
  *
  * FUNCTION:    AcpiOsMapMemory
@@ -599,6 +604,7 @@ AcpiOsUnmapMemory (
 
     return;
 }
+#endif
 
 
 /******************************************************************************
@@ -626,6 +632,33 @@ AcpiOsAllocate (
 }
 
 
+#ifdef USE_NATIVE_ALLOCATE_ZEROED
+/******************************************************************************
+ *
+ * FUNCTION:    AcpiOsAllocateZeroed
+ *
+ * PARAMETERS:  Size                - Amount to allocate, in bytes
+ *
+ * RETURN:      Pointer to the new allocation. Null on error.
+ *
+ * DESCRIPTION: Allocate and zero memory. Algorithm is dependent on the OS.
+ *
+ *****************************************************************************/
+
+void *
+AcpiOsAllocateZeroed (
+    ACPI_SIZE               Size)
+{
+    void                    *Mem;
+
+
+    Mem = (void *) calloc (1, (size_t) Size);
+
+    return (Mem);
+}
+#endif
+
+
 /******************************************************************************
  *
  * FUNCTION:    AcpiOsFree
@@ -1486,6 +1519,26 @@ AcpiOsExecute (
     return (0);
 }
 
+#else /* ACPI_SINGLE_THREADED */
+ACPI_THREAD_ID
+AcpiOsGetThreadId (
+    void)
+{
+    return (1);
+}
+
+ACPI_STATUS
+AcpiOsExecute (
+    ACPI_EXECUTE_TYPE       Type,
+    ACPI_OSD_EXEC_CALLBACK  Function,
+    void                    *Context)
+{
+
+    Function (Context);
+
+    return (AE_OK);
+}
+
 #endif /* ACPI_SINGLE_THREADED */