EFI: Rename EFI stuff to ACPI_EFI to improve portability

This patch renames the EFI stuffs to ACPI_EFI stuffs so that there won't be
namespace conflicts when this code is ported to the different EFI
development environment.
No functional changes. Lv Zheng.

Signed-off-by: Lv Zheng <lv.zheng@intel.com>

4 files changed, 572 insertions, 571 deletions

diff --git a/source/include/platform/acefi.h b/source/include/platform/acefi.h
index a545fb95a..859e7554d 100644
--- a/source/include/platform/acefi.h
+++ b/source/include/platform/acefi.h
@@ -123,11 +123,11 @@
 #endif
 
 #ifdef _MSC_EXTENSIONS
-#define EFIAPI __cdecl
+#define ACPI_EFI_API __cdecl
 #elif USE_MS_ABI
-#define EFIAPI __attribute__((ms_abi))
+#define ACPI_EFI_API __attribute__((ms_abi))
 #else
-#define EFIAPI
+#define ACPI_EFI_API
 #endif
 
 #define VOID        void
@@ -153,7 +153,7 @@
 #define UINTN       uint64_t
 #define INTN        int64_t
 
-#define EFIERR(a)           (0x8000000000000000 | a)
+#define ACPI_EFI_ERR(a)             (0x8000000000000000 | a)
 
 #else
 
@@ -163,7 +163,7 @@
 #define UINTN       uint32_t
 #define INTN        int32_t
 
-#define EFIERR(a)           (0x80000000 | a)
+#define ACPI_EFI_ERR(a)             (0x80000000 | a)
 
 #endif
 
@@ -326,17 +326,17 @@ UINT64 efi_call10(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3,
 
 #endif
 
-struct _SIMPLE_TEXT_OUTPUT_INTERFACE;
-struct _SIMPLE_INPUT_INTERFACE;
-struct _EFI_FILE_IO_INTERFACE;
-struct _EFI_FILE_HANDLE;
-struct _EFI_BOOT_SERVICES;
-struct _EFI_RUNTIME_SERVICES;
-struct _EFI_SYSTEM_TABLE;
-
-extern struct _EFI_SYSTEM_TABLE         *ST;
-extern struct _EFI_BOOT_SERVICES        *BS;
-extern struct _EFI_RUNTIME_SERVICES     *RT;
+struct _ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE;
+struct _ACPI_SIMPLE_INPUT_INTERFACE;
+struct _ACPI_EFI_FILE_IO_INTERFACE;
+struct _ACPI_EFI_FILE_HANDLE;
+struct _ACPI_EFI_BOOT_SERVICES;
+struct _ACPI_EFI_RUNTIME_SERVICES;
+struct _ACPI_EFI_SYSTEM_TABLE;
+
+extern struct _ACPI_EFI_SYSTEM_TABLE        *ST;
+extern struct _ACPI_EFI_BOOT_SERVICES       *BS;
+extern struct _ACPI_EFI_RUNTIME_SERVICES    *RT;
 
 typedef union acpi_efi_file             ACPI_EFI_FILE;
 
diff --git a/source/include/platform/acefiex.h b/source/include/platform/acefiex.h
index 1b74b545b..aecb38e6c 100644
--- a/source/include/platform/acefiex.h
+++ b/source/include/platform/acefiex.h
@@ -117,42 +117,42 @@
 #define __ACEFIEX_H__
 
 
-#define EFI_ERROR(a)              (((INTN) a) < 0)
-#define EFI_SUCCESS                             0
-#define EFI_LOAD_ERROR                  EFIERR(1)
-#define EFI_INVALID_PARAMETER           EFIERR(2)
-#define EFI_UNSUPPORTED                 EFIERR(3)
-#define EFI_BAD_BUFFER_SIZE             EFIERR(4)
-#define EFI_BUFFER_TOO_SMALL            EFIERR(5)
-#define EFI_NOT_READY                   EFIERR(6)
-#define EFI_DEVICE_ERROR                EFIERR(7)
-#define EFI_WRITE_PROTECTED             EFIERR(8)
-#define EFI_OUT_OF_RESOURCES            EFIERR(9)
-#define EFI_VOLUME_CORRUPTED            EFIERR(10)
-#define EFI_VOLUME_FULL                 EFIERR(11)
-#define EFI_NO_MEDIA                    EFIERR(12)
-#define EFI_MEDIA_CHANGED               EFIERR(13)
-#define EFI_NOT_FOUND                   EFIERR(14)
-#define EFI_ACCESS_DENIED               EFIERR(15)
-#define EFI_NO_RESPONSE                 EFIERR(16)
-#define EFI_NO_MAPPING                  EFIERR(17)
-#define EFI_TIMEOUT                     EFIERR(18)
-#define EFI_NOT_STARTED                 EFIERR(19)
-#define EFI_ALREADY_STARTED             EFIERR(20)
-#define EFI_ABORTED                     EFIERR(21)
-#define EFI_PROTOCOL_ERROR              EFIERR(24)
-
-
-typedef UINTN EFI_STATUS;
-typedef VOID *EFI_HANDLE;
-typedef VOID *EFI_EVENT;
+#define ACPI_EFI_ERROR(a)               (((INTN) a) < 0)
+#define ACPI_EFI_SUCCESS                0
+#define ACPI_EFI_LOAD_ERROR             ACPI_EFI_ERR(1)
+#define ACPI_EFI_INVALID_PARAMETER      ACPI_EFI_ERR(2)
+#define ACPI_EFI_UNSUPPORTED            ACPI_EFI_ERR(3)
+#define ACPI_EFI_BAD_BUFFER_SIZE        ACPI_EFI_ERR(4)
+#define ACPI_EFI_BUFFER_TOO_SMALL       ACPI_EFI_ERR(5)
+#define ACPI_EFI_NOT_READY              ACPI_EFI_ERR(6)
+#define ACPI_EFI_DEVICE_ERROR           ACPI_EFI_ERR(7)
+#define ACPI_EFI_WRITE_PROTECTED        ACPI_EFI_ERR(8)
+#define ACPI_EFI_OUT_OF_RESOURCES       ACPI_EFI_ERR(9)
+#define ACPI_EFI_VOLUME_CORRUPTED       ACPI_EFI_ERR(10)
+#define ACPI_EFI_VOLUME_FULL            ACPI_EFI_ERR(11)
+#define ACPI_EFI_NO_MEDIA               ACPI_EFI_ERR(12)
+#define ACPI_EFI_MEDIA_CHANGED          ACPI_EFI_ERR(13)
+#define ACPI_EFI_NOT_FOUND              ACPI_EFI_ERR(14)
+#define ACPI_EFI_ACCESS_DENIED          ACPI_EFI_ERR(15)
+#define ACPI_EFI_NO_RESPONSE            ACPI_EFI_ERR(16)
+#define ACPI_EFI_NO_MAPPING             ACPI_EFI_ERR(17)
+#define ACPI_EFI_TIMEOUT                ACPI_EFI_ERR(18)
+#define ACPI_EFI_NOT_STARTED            ACPI_EFI_ERR(19)
+#define ACPI_EFI_ALREADY_STARTED        ACPI_EFI_ERR(20)
+#define ACPI_EFI_ABORTED                ACPI_EFI_ERR(21)
+#define ACPI_EFI_PROTOCOL_ERROR         ACPI_EFI_ERR(24)
+
+
+typedef UINTN ACPI_EFI_STATUS;
+typedef VOID *ACPI_EFI_HANDLE;
+typedef VOID *ACPI_EFI_EVENT;
 
 typedef struct {
     UINT32  Data1;
     UINT16  Data2;
     UINT16  Data3;
     UINT8   Data4[8];
-} EFI_GUID;
+} ACPI_EFI_GUID;
 
 typedef struct {
     UINT16 Year;       /* 1998 - 20XX */
@@ -166,142 +166,142 @@ typedef struct {
     INT16  TimeZone;   /* -1440 to 1440 or 2047 */
     UINT8  Daylight;
     UINT8  Pad2;
-} EFI_TIME;
+} ACPI_EFI_TIME;
 
-typedef struct _EFI_DEVICE_PATH {
+typedef struct _ACPI_EFI_DEVICE_PATH {
         UINT8                           Type;
         UINT8                           SubType;
         UINT8                           Length[2];
-} EFI_DEVICE_PATH;
+} ACPI_EFI_DEVICE_PATH;
 
-typedef UINT64          EFI_PHYSICAL_ADDRESS;
-typedef UINT64          EFI_VIRTUAL_ADDRESS;
+typedef UINT64          ACPI_EFI_PHYSICAL_ADDRESS;
+typedef UINT64          ACPI_EFI_VIRTUAL_ADDRESS;
 
 typedef enum {
-    AllocateAnyPages,
-    AllocateMaxAddress,
-    AllocateAddress,
-    MaxAllocateType
-} EFI_ALLOCATE_TYPE;
+    AcpiEfiAllocateAnyPages,
+    AcpiEfiAllocateMaxAddress,
+    AcpiEfiAllocateAddress,
+    AcpiEfiMaxAllocateType
+} ACPI_EFI_ALLOCATE_TYPE;
 
 typedef enum {
-    EfiReservedMemoryType,
-    EfiLoaderCode,
-    EfiLoaderData,
-    EfiBootServicesCode,
-    EfiBootServicesData,
-    EfiRuntimeServicesCode,
-    EfiRuntimeServicesData,
-    EfiConventionalMemory,
-    EfiUnusableMemory,
-    EfiACPIReclaimMemory,
-    EfiACPIMemoryNVS,
-    EfiMemoryMappedIO,
-    EfiMemoryMappedIOPortSpace,
-    EfiPalCode,
-    EfiMaxMemoryType
-} EFI_MEMORY_TYPE;
+    AcpiEfiReservedMemoryType,
+    AcpiEfiLoaderCode,
+    AcpiEfiLoaderData,
+    AcpiEfiBootServicesCode,
+    AcpiEfiBootServicesData,
+    AcpiEfiRuntimeServicesCode,
+    AcpiEfiRuntimeServicesData,
+    AcpiEfiConventionalMemory,
+    AcpiEfiUnusableMemory,
+    AcpiEfiACPIReclaimMemory,
+    AcpiEfiACPIMemoryNVS,
+    AcpiEfiMemoryMappedIO,
+    AcpiEfiMemoryMappedIOPortSpace,
+    AcpiEfiPalCode,
+    AcpiEfiMaxMemoryType
+} ACPI_EFI_MEMORY_TYPE;
 
 /* possible caching types for the memory range */
-#define EFI_MEMORY_UC           0x0000000000000001
-#define EFI_MEMORY_WC           0x0000000000000002
-#define EFI_MEMORY_WT           0x0000000000000004
-#define EFI_MEMORY_WB           0x0000000000000008
-#define EFI_MEMORY_UCE          0x0000000000000010
+#define ACPI_EFI_MEMORY_UC      0x0000000000000001
+#define ACPI_EFI_MEMORY_WC      0x0000000000000002
+#define ACPI_EFI_MEMORY_WT      0x0000000000000004
+#define ACPI_EFI_MEMORY_WB      0x0000000000000008
+#define ACPI_EFI_MEMORY_UCE     0x0000000000000010
 
 /* physical memory protection on range */
-#define EFI_MEMORY_WP           0x0000000000001000
-#define EFI_MEMORY_RP           0x0000000000002000
-#define EFI_MEMORY_XP           0x0000000000004000
+#define ACPI_EFI_MEMORY_WP      0x0000000000001000
+#define ACPI_EFI_MEMORY_RP      0x0000000000002000
+#define ACPI_EFI_MEMORY_XP      0x0000000000004000
 
 /* range requires a runtime mapping */
-#define EFI_MEMORY_RUNTIME      0x8000000000000000
+#define ACPI_EFI_MEMORY_RUNTIME 0x8000000000000000
 
-#define EFI_MEMORY_DESCRIPTOR_VERSION  1
+#define ACPI_EFI_MEMORY_DESCRIPTOR_VERSION  1
 typedef struct {
     UINT32                          Type;
     UINT32                          Pad;
-    EFI_PHYSICAL_ADDRESS            PhysicalStart;
-    EFI_VIRTUAL_ADDRESS             VirtualStart;
+    ACPI_EFI_PHYSICAL_ADDRESS       PhysicalStart;
+    ACPI_EFI_VIRTUAL_ADDRESS        VirtualStart;
     UINT64                          NumberOfPages;
     UINT64                          Attribute;
-} EFI_MEMORY_DESCRIPTOR;
+} ACPI_EFI_MEMORY_DESCRIPTOR;
 
-typedef struct _EFI_TABLE_HEARDER {
+typedef struct _ACPI_EFI_TABLE_HEARDER {
     UINT64                      Signature;
     UINT32                      Revision;
     UINT32                      HeaderSize;
     UINT32                      CRC32;
     UINT32                      Reserved;
-} EFI_TABLE_HEADER;
+} ACPI_EFI_TABLE_HEADER;
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_UNKNOWN_INTERFACE) (
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_UNKNOWN_INTERFACE) (
     void);
 
 
 /*
  * Text output protocol
  */
-#define SIMPLE_TEXT_OUTPUT_PROTOCOL \
+#define ACPI_SIMPLE_TEXT_OUTPUT_PROTOCOL \
     { 0x387477c2, 0x69c7, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_TEXT_RESET) (
-    struct _SIMPLE_TEXT_OUTPUT_INTERFACE    *This,
-    BOOLEAN                                 ExtendedVerification);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_TEXT_RESET) (
+    struct _ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE   *This,
+    BOOLEAN                                     ExtendedVerification);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_TEXT_OUTPUT_STRING) (
-    struct _SIMPLE_TEXT_OUTPUT_INTERFACE    *This,
-    CHAR16                                  *String);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_TEXT_OUTPUT_STRING) (
+    struct _ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE   *This,
+    CHAR16                                      *String);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_TEXT_TEST_STRING) (
-    struct _SIMPLE_TEXT_OUTPUT_INTERFACE    *This,
-    CHAR16                                  *String);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_TEXT_TEST_STRING) (
+    struct _ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE   *This,
+    CHAR16                                      *String);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_TEXT_QUERY_MODE) (
-    struct _SIMPLE_TEXT_OUTPUT_INTERFACE    *This,
-    UINTN                                   ModeNumber,
-    UINTN                                   *Columns,
-    UINTN                                   *Rows);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_TEXT_QUERY_MODE) (
+    struct _ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE   *This,
+    UINTN                                       ModeNumber,
+    UINTN                                       *Columns,
+    UINTN                                       *Rows);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_TEXT_SET_MODE) (
-    struct _SIMPLE_TEXT_OUTPUT_INTERFACE    *This,
-    UINTN                                   ModeNumber);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_TEXT_SET_MODE) (
+    struct _ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE   *This,
+    UINTN                                       ModeNumber);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_TEXT_SET_ATTRIBUTE) (
-    struct _SIMPLE_TEXT_OUTPUT_INTERFACE    *This,
-    UINTN                                   Attribute);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_TEXT_SET_ATTRIBUTE) (
+    struct _ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE   *This,
+    UINTN                                       Attribute);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_TEXT_CLEAR_SCREEN) (
-    struct _SIMPLE_TEXT_OUTPUT_INTERFACE    *This);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_TEXT_CLEAR_SCREEN) (
+    struct _ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE   *This);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_TEXT_SET_CURSOR_POSITION) (
-    struct _SIMPLE_TEXT_OUTPUT_INTERFACE    *This,
-    UINTN                                   Column,
-    UINTN                                   Row);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_TEXT_SET_CURSOR_POSITION) (
+    struct _ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE   *This,
+    UINTN                                       Column,
+    UINTN                                       Row);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_TEXT_ENABLE_CURSOR) (
-    struct _SIMPLE_TEXT_OUTPUT_INTERFACE    *This,
-    BOOLEAN                                 Enable);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_TEXT_ENABLE_CURSOR) (
+    struct _ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE   *This,
+    BOOLEAN                                     Enable);
 
 typedef struct {
     INT32                           MaxMode;
@@ -310,35 +310,35 @@ typedef struct {
     INT32                           CursorColumn;
     INT32                           CursorRow;
     BOOLEAN                         CursorVisible;
-} SIMPLE_TEXT_OUTPUT_MODE;
+} ACPI_SIMPLE_TEXT_OUTPUT_MODE;
 
-typedef struct _SIMPLE_TEXT_OUTPUT_INTERFACE {
-    EFI_TEXT_RESET                  Reset;
+typedef struct _ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE {
+    ACPI_EFI_TEXT_RESET                 Reset;
 
-    EFI_TEXT_OUTPUT_STRING          OutputString;
-    EFI_TEXT_TEST_STRING            TestString;
+    ACPI_EFI_TEXT_OUTPUT_STRING         OutputString;
+    ACPI_EFI_TEXT_TEST_STRING           TestString;
 
-    EFI_TEXT_QUERY_MODE             QueryMode;
-    EFI_TEXT_SET_MODE               SetMode;
-    EFI_TEXT_SET_ATTRIBUTE          SetAttribute;
+    ACPI_EFI_TEXT_QUERY_MODE            QueryMode;
+    ACPI_EFI_TEXT_SET_MODE              SetMode;
+    ACPI_EFI_TEXT_SET_ATTRIBUTE         SetAttribute;
 
-    EFI_TEXT_CLEAR_SCREEN           ClearScreen;
-    EFI_TEXT_SET_CURSOR_POSITION    SetCursorPosition;
-    EFI_TEXT_ENABLE_CURSOR          EnableCursor;
+    ACPI_EFI_TEXT_CLEAR_SCREEN          ClearScreen;
+    ACPI_EFI_TEXT_SET_CURSOR_POSITION   SetCursorPosition;
+    ACPI_EFI_TEXT_ENABLE_CURSOR         EnableCursor;
 
-    SIMPLE_TEXT_OUTPUT_MODE         *Mode;
-} SIMPLE_TEXT_OUTPUT_INTERFACE;
+    ACPI_SIMPLE_TEXT_OUTPUT_MODE        *Mode;
+} ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE;
 
 /*
  * Text input protocol
  */
-#define SIMPLE_TEXT_INPUT_PROTOCOL  \
+#define ACPI_SIMPLE_TEXT_INPUT_PROTOCOL  \
     { 0x387477c1, 0x69c7, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
 
 typedef struct {
     UINT16                              ScanCode;
     CHAR16                              UnicodeChar;
-} EFI_INPUT_KEY;
+} ACPI_EFI_INPUT_KEY;
 
 /*
  * Baseline unicode control chars
@@ -350,210 +350,211 @@ typedef struct {
 #define CHAR_CARRIAGE_RETURN            0x000D
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_INPUT_RESET) (
-    struct _SIMPLE_INPUT_INTERFACE              *This,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_INPUT_RESET) (
+    struct _ACPI_SIMPLE_INPUT_INTERFACE         *This,
     BOOLEAN                                     ExtendedVerification);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_INPUT_READ_KEY) (
-    struct _SIMPLE_INPUT_INTERFACE              *This,
-    EFI_INPUT_KEY                               *Key);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_INPUT_READ_KEY) (
+    struct _ACPI_SIMPLE_INPUT_INTERFACE         *This,
+    ACPI_EFI_INPUT_KEY                          *Key);
 
-typedef struct _SIMPLE_INPUT_INTERFACE {
-    EFI_INPUT_RESET                     Reset;
-    EFI_INPUT_READ_KEY                  ReadKeyStroke;
-    EFI_EVENT                           WaitForKey;
-} SIMPLE_INPUT_INTERFACE;
+typedef struct _ACPI_SIMPLE_INPUT_INTERFACE {
+    ACPI_EFI_INPUT_RESET                    Reset;
+    ACPI_EFI_INPUT_READ_KEY                 ReadKeyStroke;
+    ACPI_EFI_EVENT                          WaitForKey;
+} ACPI_SIMPLE_INPUT_INTERFACE;
 
 
 /*
  * Simple file system protocol
  */
-#define SIMPLE_FILE_SYSTEM_PROTOCOL \
+#define ACPI_SIMPLE_FILE_SYSTEM_PROTOCOL \
     { 0x964e5b22, 0x6459, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_VOLUME_OPEN) (
-    struct _EFI_FILE_IO_INTERFACE               *This,
-    struct _EFI_FILE_HANDLE                     **Root);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_VOLUME_OPEN) (
+    struct _ACPI_EFI_FILE_IO_INTERFACE          *This,
+    struct _ACPI_EFI_FILE_HANDLE                **Root);
 
-#define EFI_FILE_IO_INTERFACE_REVISION   0x00010000
+#define ACPI_EFI_FILE_IO_INTERFACE_REVISION     0x00010000
 
-typedef struct _EFI_FILE_IO_INTERFACE {
+typedef struct _ACPI_EFI_FILE_IO_INTERFACE {
     UINT64                  Revision;
-    EFI_VOLUME_OPEN         OpenVolume;
-} EFI_FILE_IO_INTERFACE;
+    ACPI_EFI_VOLUME_OPEN    OpenVolume;
+} ACPI_EFI_FILE_IO_INTERFACE;
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_FILE_OPEN) (
-    struct _EFI_FILE_HANDLE                     *File,
-    struct _EFI_FILE_HANDLE                     **NewHandle,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_FILE_OPEN) (
+    struct _ACPI_EFI_FILE_HANDLE                *File,
+    struct _ACPI_EFI_FILE_HANDLE                **NewHandle,
     CHAR16                                      *FileName,
     UINT64                                      OpenMode,
     UINT64                                      Attributes);
 
 /* Values for OpenMode used above */
 
-#define EFI_FILE_MODE_READ      0x0000000000000001
-#define EFI_FILE_MODE_WRITE     0x0000000000000002
-#define EFI_FILE_MODE_CREATE    0x8000000000000000
+#define ACPI_EFI_FILE_MODE_READ     0x0000000000000001
+#define ACPI_EFI_FILE_MODE_WRITE    0x0000000000000002
+#define ACPI_EFI_FILE_MODE_CREATE   0x8000000000000000
 
 /* Values for Attribute used above */
 
-#define EFI_FILE_READ_ONLY      0x0000000000000001
-#define EFI_FILE_HIDDEN         0x0000000000000002
-#define EFI_FILE_SYSTEM         0x0000000000000004
-#define EFI_FILE_RESERVIED      0x0000000000000008
-#define EFI_FILE_DIRECTORY      0x0000000000000010
-#define EFI_FILE_ARCHIVE        0x0000000000000020
-#define EFI_FILE_VALID_ATTR     0x0000000000000037
+#define ACPI_EFI_FILE_READ_ONLY     0x0000000000000001
+#define ACPI_EFI_FILE_HIDDEN        0x0000000000000002
+#define ACPI_EFI_FILE_SYSTEM        0x0000000000000004
+#define ACPI_EFI_FILE_RESERVIED     0x0000000000000008
+#define ACPI_EFI_FILE_DIRECTORY     0x0000000000000010
+#define ACPI_EFI_FILE_ARCHIVE       0x0000000000000020
+#define ACPI_EFI_FILE_VALID_ATTR    0x0000000000000037
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_FILE_CLOSE) (
-    struct _EFI_FILE_HANDLE                     *File);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_FILE_CLOSE) (
+    struct _ACPI_EFI_FILE_HANDLE                *File);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_FILE_DELETE) (
-    struct _EFI_FILE_HANDLE                     *File);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_FILE_DELETE) (
+    struct _ACPI_EFI_FILE_HANDLE                *File);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_FILE_READ) (
-    struct _EFI_FILE_HANDLE                     *File,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_FILE_READ) (
+    struct _ACPI_EFI_FILE_HANDLE                *File,
     UINTN                                       *BufferSize,
     VOID                                        *Buffer);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_FILE_WRITE) (
-    struct _EFI_FILE_HANDLE                     *File,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_FILE_WRITE) (
+    struct _ACPI_EFI_FILE_HANDLE                *File,
     UINTN                                       *BufferSize,
     VOID                                        *Buffer);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_FILE_SET_POSITION) (
-    struct _EFI_FILE_HANDLE                     *File,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_FILE_SET_POSITION) (
+    struct _ACPI_EFI_FILE_HANDLE                *File,
     UINT64                                      Position);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_FILE_GET_POSITION) (
-    struct _EFI_FILE_HANDLE                     *File,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_FILE_GET_POSITION) (
+    struct _ACPI_EFI_FILE_HANDLE                *File,
     UINT64                                      *Position);
 
-#define EFI_FILE_INFO_ID \
+#define ACPI_EFI_FILE_INFO_ID \
     { 0x9576e92, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
 
 typedef struct {
     UINT64 Size;
     UINT64 FileSize;
     UINT64 PhysicalSize;
-    EFI_TIME CreateTime;
-    EFI_TIME LastAccessTime;
-    EFI_TIME ModificationTime;
+    ACPI_EFI_TIME CreateTime;
+    ACPI_EFI_TIME LastAccessTime;
+    ACPI_EFI_TIME ModificationTime;
     UINT64 Attribute;
     CHAR16 FileName[1];
-} EFI_FILE_INFO;
+} ACPI_EFI_FILE_INFO;
 
-#define SIZE_OF_EFI_FILE_INFO       ACPI_OFFSET(EFI_FILE_INFO, FileName)
+#define ACPI_EFI_FILE_INFO_SIZE \
+    ACPI_OFFSET(ACPI_EFI_FILE_INFO, FileName)
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_FILE_GET_INFO) (
-    struct _EFI_FILE_HANDLE                     *File,
-    EFI_GUID                                    *InformationType,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_FILE_GET_INFO) (
+    struct _ACPI_EFI_FILE_HANDLE                *File,
+    ACPI_EFI_GUID                               *InformationType,
     UINTN                                       *BufferSize,
     VOID                                        *Buffer);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_FILE_SET_INFO) (
-    struct _EFI_FILE_HANDLE                     *File,
-    EFI_GUID                                    *InformationType,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_FILE_SET_INFO) (
+    struct _ACPI_EFI_FILE_HANDLE                *File,
+    ACPI_EFI_GUID                               *InformationType,
     UINTN                                       BufferSize,
     VOID                                        *Buffer);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_FILE_FLUSH) (
-    struct _EFI_FILE_HANDLE                     *File);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_FILE_FLUSH) (
+    struct _ACPI_EFI_FILE_HANDLE                *File);
 
 
-#define EFI_FILE_HANDLE_REVISION         0x00010000
+#define ACPI_EFI_FILE_HANDLE_REVISION           0x00010000
 
-typedef struct _EFI_FILE_HANDLE {
-    UINT64                  Revision;
-    EFI_FILE_OPEN           Open;
-    EFI_FILE_CLOSE          Close;
-    EFI_FILE_DELETE         Delete;
-    EFI_FILE_READ           Read;
-    EFI_FILE_WRITE          Write;
-    EFI_FILE_GET_POSITION   GetPosition;
-    EFI_FILE_SET_POSITION   SetPosition;
-    EFI_FILE_GET_INFO       GetInfo;
-    EFI_FILE_SET_INFO       SetInfo;
-    EFI_FILE_FLUSH          Flush;
-} EFI_FILE, *EFI_FILE_HANDLE;
+typedef struct _ACPI_EFI_FILE_HANDLE {
+    UINT64                      Revision;
+    ACPI_EFI_FILE_OPEN          Open;
+    ACPI_EFI_FILE_CLOSE         Close;
+    ACPI_EFI_FILE_DELETE        Delete;
+    ACPI_EFI_FILE_READ          Read;
+    ACPI_EFI_FILE_WRITE         Write;
+    ACPI_EFI_FILE_GET_POSITION  GetPosition;
+    ACPI_EFI_FILE_SET_POSITION  SetPosition;
+    ACPI_EFI_FILE_GET_INFO      GetInfo;
+    ACPI_EFI_FILE_SET_INFO      SetInfo;
+    ACPI_EFI_FILE_FLUSH         Flush;
+} ACPI_EFI_FILE_STRUCT, *ACPI_EFI_FILE_HANDLE;
 
 
 /*
  * Loaded image protocol
  */
-#define LOADED_IMAGE_PROTOCOL      \
+#define ACPI_EFI_LOADED_IMAGE_PROTOCOL \
     { 0x5B1B31A1, 0x9562, 0x11d2, {0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B} }
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_IMAGE_ENTRY_POINT) (
-    EFI_HANDLE                              ImageHandle,
-    struct _EFI_SYSTEM_TABLE                *SystemTable);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_IMAGE_ENTRY_POINT) (
+    ACPI_EFI_HANDLE                         ImageHandle,
+    struct _ACPI_EFI_SYSTEM_TABLE           *SystemTable);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_IMAGE_LOAD) (
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_IMAGE_LOAD) (
     BOOLEAN                         BootPolicy,
-    EFI_HANDLE                      ParentImageHandle,
-    EFI_DEVICE_PATH                 *FilePath,
+    ACPI_EFI_HANDLE                 ParentImageHandle,
+    ACPI_EFI_DEVICE_PATH            *FilePath,
     VOID                            *SourceBuffer,
     UINTN                           SourceSize,
-    EFI_HANDLE                      *ImageHandle);
+    ACPI_EFI_HANDLE                 *ImageHandle);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_IMAGE_START) (
-    EFI_HANDLE                      ImageHandle,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_IMAGE_START) (
+    ACPI_EFI_HANDLE                 ImageHandle,
     UINTN                           *ExitDataSize,
     CHAR16                          **ExitData);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_EXIT) (
-    EFI_HANDLE                      ImageHandle,
-    EFI_STATUS                      ExitStatus,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_EXIT) (
+    ACPI_EFI_HANDLE                 ImageHandle,
+    ACPI_EFI_STATUS                 ExitStatus,
     UINTN                           ExitDataSize,
     CHAR16                          *ExitData);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_IMAGE_UNLOAD) (
-    EFI_HANDLE                      ImageHandle);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_IMAGE_UNLOAD) (
+    ACPI_EFI_HANDLE                 ImageHandle);
 
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_STALL) (
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_STALL) (
     UINTN                           Microseconds);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_SET_WATCHDOG_TIMER) (
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_SET_WATCHDOG_TIMER) (
     UINTN                           Timeout,
     UINT64                          WatchdogCode,
     UINTN                           DataSize,
@@ -563,60 +564,60 @@ EFI_STATUS
 #define EFI_IMAGE_INFORMATION_REVISION      0x1000
 typedef struct {
     UINT32                          Revision;
-    EFI_HANDLE                      ParentHandle;
-    struct _EFI_SYSTEM_TABLE        *SystemTable;
-    EFI_HANDLE                      DeviceHandle;
-    EFI_DEVICE_PATH                 *FilePath;
+    ACPI_EFI_HANDLE                 ParentHandle;
+    struct _ACPI_EFI_SYSTEM_TABLE   *SystemTable;
+    ACPI_EFI_HANDLE                 DeviceHandle;
+    ACPI_EFI_DEVICE_PATH            *FilePath;
     VOID                            *Reserved;
     UINT32                          LoadOptionsSize;
     VOID                            *LoadOptions;
     VOID                            *ImageBase;
     UINT64                          ImageSize;
-    EFI_MEMORY_TYPE                 ImageCodeType;
-    EFI_MEMORY_TYPE                 ImageDataType;
-    EFI_IMAGE_UNLOAD                Unload;
+    ACPI_EFI_MEMORY_TYPE            ImageCodeType;
+    ACPI_EFI_MEMORY_TYPE            ImageDataType;
+    ACPI_EFI_IMAGE_UNLOAD           Unload;
 
-} EFI_LOADED_IMAGE;
+} ACPI_EFI_LOADED_IMAGE;
 
 
 /*
  * EFI Memory
  */
 typedef
-EFI_STATUS
-(EFIAPI *EFI_ALLOCATE_PAGES) (
-    EFI_ALLOCATE_TYPE               Type,
-    EFI_MEMORY_TYPE                 MemoryType,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_ALLOCATE_PAGES) (
+    ACPI_EFI_ALLOCATE_TYPE          Type,
+    ACPI_EFI_MEMORY_TYPE            MemoryType,
     UINTN                           NoPages,
-    EFI_PHYSICAL_ADDRESS            *Memory);
+    ACPI_EFI_PHYSICAL_ADDRESS       *Memory);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_FREE_PAGES) (
-    EFI_PHYSICAL_ADDRESS            Memory,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_FREE_PAGES) (
+    ACPI_EFI_PHYSICAL_ADDRESS       Memory,
     UINTN                           NoPages);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_GET_MEMORY_MAP) (
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_GET_MEMORY_MAP) (
     UINTN                           *MemoryMapSize,
-    EFI_MEMORY_DESCRIPTOR           *MemoryMap,
+    ACPI_EFI_MEMORY_DESCRIPTOR      *MemoryMap,
     UINTN                           *MapKey,
     UINTN                           *DescriptorSize,
     UINT32                          *DescriptorVersion);
 
-#define NextMemoryDescriptor(Ptr,Size)  ((EFI_MEMORY_DESCRIPTOR *) (((UINT8 *) Ptr) + Size))
+#define NextMemoryDescriptor(Ptr,Size)  ((ACPI_EFI_MEMORY_DESCRIPTOR *) (((UINT8 *) Ptr) + Size))
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_ALLOCATE_POOL) (
-    EFI_MEMORY_TYPE                 PoolType,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_ALLOCATE_POOL) (
+    ACPI_EFI_MEMORY_TYPE            PoolType,
     UINTN                           Size,
     VOID                            **Buffer);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_FREE_POOL) (
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_FREE_POOL) (
     VOID                            *Buffer);
 
 
@@ -627,185 +628,185 @@ typedef struct {
     UINT32 Resolution;
     UINT32 Accuracy;
     BOOLEAN SetsToZero;
-} EFI_TIME_CAPABILITIES;
+} ACPI_EFI_TIME_CAPABILITIES;
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_GET_TIME) (
-    EFI_TIME                    *Time,
-    EFI_TIME_CAPABILITIES       *Capabilities);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_GET_TIME) (
+    ACPI_EFI_TIME               *Time,
+    ACPI_EFI_TIME_CAPABILITIES  *Capabilities);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_SET_TIME) (
-    EFI_TIME                    *Time);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_SET_TIME) (
+    ACPI_EFI_TIME               *Time);
 
 
 /*
  * Protocol handler functions
  */
 typedef enum {
-    EFI_NATIVE_INTERFACE,
-    EFI_PCODE_INTERFACE
-} EFI_INTERFACE_TYPE;
+    ACPI_EFI_NATIVE_INTERFACE,
+    ACPI_EFI_PCODE_INTERFACE
+} ACPI_EFI_INTERFACE_TYPE;
 
 typedef enum {
-    AllHandles,
-    ByRegisterNotify,
-    ByProtocol
-} EFI_LOCATE_SEARCH_TYPE;
+    AcpiEfiAllHandles,
+    AcpiEfiByRegisterNotify,
+    AcpiEfiByProtocol
+} ACPI_EFI_LOCATE_SEARCH_TYPE;
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_INSTALL_PROTOCOL_INTERFACE) (
-    EFI_HANDLE                      *Handle,
-    EFI_GUID                        *Protocol,
-    EFI_INTERFACE_TYPE              InterfaceType,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_INSTALL_PROTOCOL_INTERFACE) (
+    ACPI_EFI_HANDLE                 *Handle,
+    ACPI_EFI_GUID                   *Protocol,
+    ACPI_EFI_INTERFACE_TYPE         InterfaceType,
     VOID                            *Interface);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_REINSTALL_PROTOCOL_INTERFACE) (
-    EFI_HANDLE                      Handle,
-    EFI_GUID                        *Protocol,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_REINSTALL_PROTOCOL_INTERFACE) (
+    ACPI_EFI_HANDLE                 Handle,
+    ACPI_EFI_GUID                   *Protocol,
     VOID                            *OldInterface,
     VOID                            *NewInterface);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_UNINSTALL_PROTOCOL_INTERFACE) (
-    EFI_HANDLE                      Handle,
-    EFI_GUID                        *Protocol,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_UNINSTALL_PROTOCOL_INTERFACE) (
+    ACPI_EFI_HANDLE                 Handle,
+    ACPI_EFI_GUID                   *Protocol,
     VOID                            *Interface);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_HANDLE_PROTOCOL) (
-    EFI_HANDLE                      Handle,
-    EFI_GUID                        *Protocol,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_HANDLE_PROTOCOL) (
+    ACPI_EFI_HANDLE                 Handle,
+    ACPI_EFI_GUID                   *Protocol,
     VOID                            **Interface);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_REGISTER_PROTOCOL_NOTIFY) (
-    EFI_GUID                        *Protocol,
-    EFI_EVENT                       Event,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_REGISTER_PROTOCOL_NOTIFY) (
+    ACPI_EFI_GUID                   *Protocol,
+    ACPI_EFI_EVENT                  Event,
     VOID                            **Registration);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_LOCATE_HANDLE) (
-    EFI_LOCATE_SEARCH_TYPE          SearchType,
-    EFI_GUID                        *Protocol,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_LOCATE_HANDLE) (
+    ACPI_EFI_LOCATE_SEARCH_TYPE     SearchType,
+    ACPI_EFI_GUID                   *Protocol,
     VOID                            *SearchKey,
     UINTN                           *BufferSize,
-    EFI_HANDLE                      *Buffer);
+    ACPI_EFI_HANDLE                 *Buffer);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_LOCATE_DEVICE_PATH) (
-    EFI_GUID                        *Protocol,
-    EFI_DEVICE_PATH                 **DevicePath,
-    EFI_HANDLE                      *Device);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_LOCATE_DEVICE_PATH) (
+    ACPI_EFI_GUID                   *Protocol,
+    ACPI_EFI_DEVICE_PATH            **DevicePath,
+    ACPI_EFI_HANDLE                 *Device);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_INSTALL_CONFIGURATION_TABLE) (
-    EFI_GUID                        *Guid,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_INSTALL_CONFIGURATION_TABLE) (
+    ACPI_EFI_GUID                   *Guid,
     VOID                            *Table);
 
-#define EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL  0x00000001
-#define EFI_OPEN_PROTOCOL_GET_PROTOCOL        0x00000002
-#define EFI_OPEN_PROTOCOL_TEST_PROTOCOL       0x00000004
-#define EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 0x00000008
-#define EFI_OPEN_PROTOCOL_BY_DRIVER           0x00000010
-#define EFI_OPEN_PROTOCOL_EXCLUSIVE           0x00000020
+#define ACPI_EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL  0x00000001
+#define ACPI_EFI_OPEN_PROTOCOL_GET_PROTOCOL        0x00000002
+#define ACPI_EFI_OPEN_PROTOCOL_TEST_PROTOCOL       0x00000004
+#define ACPI_EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 0x00000008
+#define ACPI_EFI_OPEN_PROTOCOL_BY_DRIVER           0x00000010
+#define ACPI_EFI_OPEN_PROTOCOL_EXCLUSIVE           0x00000020
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_OPEN_PROTOCOL) (
-    EFI_HANDLE                      Handle,
-    EFI_GUID                        *Protocol,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_OPEN_PROTOCOL) (
+    ACPI_EFI_HANDLE                 Handle,
+    ACPI_EFI_GUID                   *Protocol,
     VOID                            **Interface,
-    EFI_HANDLE                      AgentHandle,
-    EFI_HANDLE                      ControllerHandle,
+    ACPI_EFI_HANDLE                 AgentHandle,
+    ACPI_EFI_HANDLE                 ControllerHandle,
     UINT32                          Attributes);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_CLOSE_PROTOCOL) (
-    EFI_HANDLE                      Handle,
-    EFI_GUID                        *Protocol,
-    EFI_HANDLE                      AgentHandle,
-    EFI_HANDLE                      ControllerHandle);
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_CLOSE_PROTOCOL) (
+    ACPI_EFI_HANDLE                 Handle,
+    ACPI_EFI_GUID                   *Protocol,
+    ACPI_EFI_HANDLE                 AgentHandle,
+    ACPI_EFI_HANDLE                 ControllerHandle);
 
 typedef struct {
-    EFI_HANDLE                  AgentHandle;
-    EFI_HANDLE                  ControllerHandle;
-    UINT32                      Attributes;
-    UINT32                      OpenCount;
-} EFI_OPEN_PROTOCOL_INFORMATION_ENTRY;
+    ACPI_EFI_HANDLE                 AgentHandle;
+    ACPI_EFI_HANDLE                 ControllerHandle;
+    UINT32                          Attributes;
+    UINT32                          OpenCount;
+} ACPI_EFI_OPEN_PROTOCOL_INFORMATION_ENTRY;
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_OPEN_PROTOCOL_INFORMATION) (
-    EFI_HANDLE                      Handle,
-    EFI_GUID                        *Protocol,
-    EFI_OPEN_PROTOCOL_INFORMATION_ENTRY **EntryBuffer,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_OPEN_PROTOCOL_INFORMATION) (
+    ACPI_EFI_HANDLE                 Handle,
+    ACPI_EFI_GUID                   *Protocol,
+    ACPI_EFI_OPEN_PROTOCOL_INFORMATION_ENTRY **EntryBuffer,
     UINTN                           *EntryCount);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_PROTOCOLS_PER_HANDLE) (
-    EFI_HANDLE                      Handle,
-    EFI_GUID                        ***ProtocolBuffer,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_PROTOCOLS_PER_HANDLE) (
+    ACPI_EFI_HANDLE                 Handle,
+    ACPI_EFI_GUID                   ***ProtocolBuffer,
     UINTN                           *ProtocolBufferCount);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_LOCATE_HANDLE_BUFFER) (
-    EFI_LOCATE_SEARCH_TYPE          SearchType,
-    EFI_GUID                        *Protocol,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_LOCATE_HANDLE_BUFFER) (
+    ACPI_EFI_LOCATE_SEARCH_TYPE     SearchType,
+    ACPI_EFI_GUID                   *Protocol,
     VOID                            *SearchKey,
     UINTN                           *NoHandles,
-    EFI_HANDLE                      **Buffer);
+    ACPI_EFI_HANDLE                 **Buffer);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_LOCATE_PROTOCOL) (
-    EFI_GUID                        *Protocol,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_LOCATE_PROTOCOL) (
+    ACPI_EFI_GUID                   *Protocol,
     VOID                            *Registration,
     VOID                            **Interface);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_INSTALL_MULTIPLE_PROTOCOL_INTERFACES) (
-    EFI_HANDLE                      *Handle,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_INSTALL_MULTIPLE_PROTOCOL_INTERFACES) (
+    ACPI_EFI_HANDLE                 *Handle,
     ...);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES) (
-    EFI_HANDLE                      Handle,
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES) (
+    ACPI_EFI_HANDLE                 Handle,
     ...);
 
 typedef
-EFI_STATUS
-(EFIAPI *EFI_CALCULATE_CRC32) (
+ACPI_EFI_STATUS
+(ACPI_EFI_API *ACPI_EFI_CALCULATE_CRC32) (
     VOID                            *Data,
     UINTN                           DataSize,
     UINT32                          *Crc32);
 
 typedef
 VOID
-(EFIAPI *EFI_COPY_MEM) (
+(ACPI_EFI_API *ACPI_EFI_COPY_MEM) (
     VOID                            *Destination,
     VOID                            *Source,
     UINTN                           Length);
 
 typedef
 VOID
-(EFIAPI *EFI_SET_MEM) (
+(ACPI_EFI_API *ACPI_EFI_SET_MEM) (
     VOID                            *Buffer,
     UINTN                           Size,
     UINT8                           Value);
@@ -813,143 +814,143 @@ VOID
 /*
  * EFI Boot Services Table
  */
-#define EFI_BOOT_SERVICES_SIGNATURE     0x56524553544f4f42
-#define EFI_BOOT_SERVICES_REVISION      (EFI_SPECIFICATION_MAJOR_REVISION<<16) | (EFI_SPECIFICATION_MINOR_REVISION)
+#define ACPI_EFI_BOOT_SERVICES_SIGNATURE 0x56524553544f4f42
+#define ACPI_EFI_BOOT_SERVICES_REVISION  (ACPI_EFI_SPECIFICATION_MAJOR_REVISION<<16) | (ACPI_EFI_SPECIFICATION_MINOR_REVISION)
 
-typedef struct _EFI_BOOT_SERVICES {
-    EFI_TABLE_HEADER                Hdr;
+typedef struct _ACPI_EFI_BOOT_SERVICES {
+    ACPI_EFI_TABLE_HEADER               Hdr;
 
 #if 0
-    EFI_RAISE_TPL                   RaiseTPL;
-    EFI_RESTORE_TPL                 RestoreTPL;
+    ACPI_EFI_RAISE_TPL                  RaiseTPL;
+    ACPI_EFI_RESTORE_TPL                RestoreTPL;
 #else
-    EFI_UNKNOWN_INTERFACE           RaiseTPL;
-    EFI_UNKNOWN_INTERFACE           RestoreTPL;
+    ACPI_EFI_UNKNOWN_INTERFACE          RaiseTPL;
+    ACPI_EFI_UNKNOWN_INTERFACE          RestoreTPL;
 #endif
 
-    EFI_ALLOCATE_PAGES              AllocatePages;
-    EFI_FREE_PAGES                  FreePages;
-    EFI_GET_MEMORY_MAP              GetMemoryMap;
-    EFI_ALLOCATE_POOL               AllocatePool;
-    EFI_FREE_POOL                   FreePool;
+    ACPI_EFI_ALLOCATE_PAGES             AllocatePages;
+    ACPI_EFI_FREE_PAGES                 FreePages;
+    ACPI_EFI_GET_MEMORY_MAP             GetMemoryMap;
+    ACPI_EFI_ALLOCATE_POOL              AllocatePool;
+    ACPI_EFI_FREE_POOL                  FreePool;
 
 #if 0
-    EFI_CREATE_EVENT                CreateEvent;
-    EFI_SET_TIMER                   SetTimer;
-    EFI_WAIT_FOR_EVENT              WaitForEvent;
-    EFI_SIGNAL_EVENT                SignalEvent;
-    EFI_CLOSE_EVENT                 CloseEvent;
-    EFI_CHECK_EVENT                 CheckEvent;
+    ACPI_EFI_CREATE_EVENT               CreateEvent;
+    ACPI_EFI_SET_TIMER                  SetTimer;
+    ACPI_EFI_WAIT_FOR_EVENT             WaitForEvent;
+    ACPI_EFI_SIGNAL_EVENT               SignalEvent;
+    ACPI_EFI_CLOSE_EVENT                CloseEvent;
+    ACPI_EFI_CHECK_EVENT                CheckEvent;
 #else
-    EFI_UNKNOWN_INTERFACE           CreateEvent;
-    EFI_UNKNOWN_INTERFACE           SetTimer;
-    EFI_UNKNOWN_INTERFACE           WaitForEvent;
-    EFI_UNKNOWN_INTERFACE           SignalEvent;
-    EFI_UNKNOWN_INTERFACE           CloseEvent;
-    EFI_UNKNOWN_INTERFACE           CheckEvent;
+    ACPI_EFI_UNKNOWN_INTERFACE          CreateEvent;
+    ACPI_EFI_UNKNOWN_INTERFACE          SetTimer;
+    ACPI_EFI_UNKNOWN_INTERFACE          WaitForEvent;
+    ACPI_EFI_UNKNOWN_INTERFACE          SignalEvent;
+    ACPI_EFI_UNKNOWN_INTERFACE          CloseEvent;
+    ACPI_EFI_UNKNOWN_INTERFACE          CheckEvent;
 #endif
 
-    EFI_INSTALL_PROTOCOL_INTERFACE  InstallProtocolInterface;
-    EFI_REINSTALL_PROTOCOL_INTERFACE ReinstallProtocolInterface;
-    EFI_UNINSTALL_PROTOCOL_INTERFACE UninstallProtocolInterface;
-    EFI_HANDLE_PROTOCOL             HandleProtocol;
-    EFI_HANDLE_PROTOCOL             PCHandleProtocol;
-    EFI_REGISTER_PROTOCOL_NOTIFY    RegisterProtocolNotify;
-    EFI_LOCATE_HANDLE               LocateHandle;
-    EFI_LOCATE_DEVICE_PATH          LocateDevicePath;
-    EFI_INSTALL_CONFIGURATION_TABLE InstallConfigurationTable;
-
-    EFI_IMAGE_LOAD                  LoadImage;
-    EFI_IMAGE_START                 StartImage;
-    EFI_EXIT                        Exit;
-    EFI_IMAGE_UNLOAD                UnloadImage;
+    ACPI_EFI_INSTALL_PROTOCOL_INTERFACE InstallProtocolInterface;
+    ACPI_EFI_REINSTALL_PROTOCOL_INTERFACE ReinstallProtocolInterface;
+    ACPI_EFI_UNINSTALL_PROTOCOL_INTERFACE UninstallProtocolInterface;
+    ACPI_EFI_HANDLE_PROTOCOL            HandleProtocol;
+    ACPI_EFI_HANDLE_PROTOCOL            PCHandleProtocol;
+    ACPI_EFI_REGISTER_PROTOCOL_NOTIFY   RegisterProtocolNotify;
+    ACPI_EFI_LOCATE_HANDLE              LocateHandle;
+    ACPI_EFI_LOCATE_DEVICE_PATH         LocateDevicePath;
+    ACPI_EFI_INSTALL_CONFIGURATION_TABLE InstallConfigurationTable;
+
+    ACPI_EFI_IMAGE_LOAD                 LoadImage;
+    ACPI_EFI_IMAGE_START                StartImage;
+    ACPI_EFI_EXIT                       Exit;
+    ACPI_EFI_IMAGE_UNLOAD               UnloadImage;
 
 #if 0
-    EFI_EXIT_BOOT_SERVICES          ExitBootServices;
-    EFI_GET_NEXT_MONOTONIC_COUNT    GetNextMonotonicCount;
+    ACPI_EFI_EXIT_BOOT_SERVICES         ExitBootServices;
+    ACPI_EFI_GET_NEXT_MONOTONIC_COUNT   GetNextMonotonicCount;
 #else
-    EFI_UNKNOWN_INTERFACE           ExitBootServices;
-    EFI_UNKNOWN_INTERFACE           GetNextMonotonicCount;
+    ACPI_EFI_UNKNOWN_INTERFACE          ExitBootServices;
+    ACPI_EFI_UNKNOWN_INTERFACE          GetNextMonotonicCount;
 #endif
-    EFI_STALL                       Stall;
-    EFI_SET_WATCHDOG_TIMER          SetWatchdogTimer;
+    ACPI_EFI_STALL                      Stall;
+    ACPI_EFI_SET_WATCHDOG_TIMER         SetWatchdogTimer;
 
 #if 0
-    EFI_CONNECT_CONTROLLER          ConnectController;
-    EFI_DISCONNECT_CONTROLLER       DisconnectController;
+    ACPI_EFI_CONNECT_CONTROLLER         ConnectController;
+    ACPI_EFI_DISCONNECT_CONTROLLER      DisconnectController;
 #else
-    EFI_UNKNOWN_INTERFACE           ConnectController;
-    EFI_UNKNOWN_INTERFACE           DisconnectController;
+    ACPI_EFI_UNKNOWN_INTERFACE          ConnectController;
+    ACPI_EFI_UNKNOWN_INTERFACE          DisconnectController;
 #endif
 
-    EFI_OPEN_PROTOCOL               OpenProtocol;
-    EFI_CLOSE_PROTOCOL              CloseProtocol;
-    EFI_OPEN_PROTOCOL_INFORMATION   OpenProtocolInformation;
-    EFI_PROTOCOLS_PER_HANDLE        ProtocolsPerHandle;
-    EFI_LOCATE_HANDLE_BUFFER        LocateHandleBuffer;
-    EFI_LOCATE_PROTOCOL             LocateProtocol;
-    EFI_INSTALL_MULTIPLE_PROTOCOL_INTERFACES InstallMultipleProtocolInterfaces;
-    EFI_UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES UninstallMultipleProtocolInterfaces;
+    ACPI_EFI_OPEN_PROTOCOL              OpenProtocol;
+    ACPI_EFI_CLOSE_PROTOCOL             CloseProtocol;
+    ACPI_EFI_OPEN_PROTOCOL_INFORMATION  OpenProtocolInformation;
+    ACPI_EFI_PROTOCOLS_PER_HANDLE       ProtocolsPerHandle;
+    ACPI_EFI_LOCATE_HANDLE_BUFFER       LocateHandleBuffer;
+    ACPI_EFI_LOCATE_PROTOCOL            LocateProtocol;
+    ACPI_EFI_INSTALL_MULTIPLE_PROTOCOL_INTERFACES InstallMultipleProtocolInterfaces;
+    ACPI_EFI_UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES UninstallMultipleProtocolInterfaces;
 
-    EFI_CALCULATE_CRC32             CalculateCrc32;
+    ACPI_EFI_CALCULATE_CRC32        CalculateCrc32;
 
-    EFI_COPY_MEM                    CopyMem;
-    EFI_SET_MEM                     SetMem;
+    ACPI_EFI_COPY_MEM               CopyMem;
+    ACPI_EFI_SET_MEM                SetMem;
 
 #if 0
-    EFI_CREATE_EVENT_EX             CreateEventEx;
+    ACPI_EFI_CREATE_EVENT_EX        CreateEventEx;
 #else
-    EFI_UNKNOWN_INTERFACE           CreateEventEx;
+    ACPI_EFI_UNKNOWN_INTERFACE      CreateEventEx;
 #endif
-} EFI_BOOT_SERVICES;
+} ACPI_EFI_BOOT_SERVICES;
 
 
 /*
  * EFI Runtime Services Table
  */
-#define EFI_RUNTIME_SERVICES_SIGNATURE  0x56524553544e5552
-#define EFI_RUNTIME_SERVICES_REVISION   (EFI_SPECIFICATION_MAJOR_REVISION<<16) | (EFI_SPECIFICATION_MINOR_REVISION)
+#define ACPI_EFI_RUNTIME_SERVICES_SIGNATURE 0x56524553544e5552
+#define ACPI_EFI_RUNTIME_SERVICES_REVISION  (ACPI_EFI_SPECIFICATION_MAJOR_REVISION<<16) | (ACPI_EFI_SPECIFICATION_MINOR_REVISION)
 
-typedef struct _EFI_RUNTIME_SERVICES {
-    EFI_TABLE_HEADER                Hdr;
+typedef struct _ACPI_EFI_RUNTIME_SERVICES {
+    ACPI_EFI_TABLE_HEADER               Hdr;
 
-    EFI_GET_TIME                    GetTime;
-    EFI_SET_TIME                    SetTime;
+    ACPI_EFI_GET_TIME                   GetTime;
+    ACPI_EFI_SET_TIME                   SetTime;
 #if 0
-    EFI_GET_WAKEUP_TIME             GetWakeupTime;
-    EFI_SET_WAKEUP_TIME             SetWakeupTime;
+    ACPI_EFI_GET_WAKEUP_TIME            GetWakeupTime;
+    ACPI_EFI_SET_WAKEUP_TIME            SetWakeupTime;
 #else
-    EFI_UNKNOWN_INTERFACE           GetWakeupTime;
-    EFI_UNKNOWN_INTERFACE           SetWakeupTime;
+    ACPI_EFI_UNKNOWN_INTERFACE          GetWakeupTime;
+    ACPI_EFI_UNKNOWN_INTERFACE          SetWakeupTime;
 #endif
 
 #if 0
-    EFI_SET_VIRTUAL_ADDRESS_MAP     SetVirtualAddressMap;
-    EFI_CONVERT_POINTER             ConvertPointer;
+    ACPI_EFI_SET_VIRTUAL_ADDRESS_MAP    SetVirtualAddressMap;
+    ACPI_EFI_CONVERT_POINTER            ConvertPointer;
 #else
-    EFI_UNKNOWN_INTERFACE           SetVirtualAddressMap;
-    EFI_UNKNOWN_INTERFACE            ConvertPointer;
+    ACPI_EFI_UNKNOWN_INTERFACE          SetVirtualAddressMap;
+    ACPI_EFI_UNKNOWN_INTERFACE          ConvertPointer;
 #endif
 
 #if 0
-    EFI_GET_VARIABLE                GetVariable;
-    EFI_GET_NEXT_VARIABLE_NAME      GetNextVariableName;
-    EFI_SET_VARIABLE                SetVariable;
+    ACPI_EFI_GET_VARIABLE               GetVariable;
+    ACPI_EFI_GET_NEXT_VARIABLE_NAME     GetNextVariableName;
+    ACPI_EFI_SET_VARIABLE               SetVariable;
 #else
-    EFI_UNKNOWN_INTERFACE           GetVariable;
-    EFI_UNKNOWN_INTERFACE           GetNextVariableName;
-    EFI_UNKNOWN_INTERFACE           SetVariable;
+    ACPI_EFI_UNKNOWN_INTERFACE          GetVariable;
+    ACPI_EFI_UNKNOWN_INTERFACE          GetNextVariableName;
+    ACPI_EFI_UNKNOWN_INTERFACE          SetVariable;
 #endif
 
 #if 0
-    EFI_GET_NEXT_HIGH_MONO_COUNT    GetNextHighMonotonicCount;
-    EFI_RESET_SYSTEM                ResetSystem;
+    ACPI_EFI_GET_NEXT_HIGH_MONO_COUNT   GetNextHighMonotonicCount;
+    ACPI_EFI_RESET_SYSTEM               ResetSystem;
 #else
-    EFI_UNKNOWN_INTERFACE           GetNextHighMonotonicCount;
-    EFI_UNKNOWN_INTERFACE           ResetSystem;
+    ACPI_EFI_UNKNOWN_INTERFACE          GetNextHighMonotonicCount;
+    ACPI_EFI_UNKNOWN_INTERFACE          ResetSystem;
 #endif
 
-} EFI_RUNTIME_SERVICES;
+} ACPI_EFI_RUNTIME_SERVICES;
 
 
 /*
@@ -959,50 +960,50 @@ typedef struct _EFI_RUNTIME_SERVICES {
 /*
  * EFI Configuration Table and GUID definitions
  */
-#define ACPI_TABLE_GUID    \
+#define ACPI_TABLE_GUID \
     { 0xeb9d2d30, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
-#define ACPI_20_TABLE_GUID  \
+#define ACPI_20_TABLE_GUID \
     { 0x8868e871, 0xe4f1, 0x11d3, {0xbc, 0x22, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} }
 
-typedef struct _EFI_CONFIGURATION_TABLE {
-    EFI_GUID                VendorGuid;
+typedef struct _ACPI_EFI_CONFIGURATION_TABLE {
+    ACPI_EFI_GUID           VendorGuid;
     VOID                    *VendorTable;
-} EFI_CONFIGURATION_TABLE;
+} ACPI_EFI_CONFIGURATION_TABLE;
 
 
-#define EFI_SYSTEM_TABLE_SIGNATURE      0x5453595320494249
-#define EFI_SYSTEM_TABLE_REVISION      (EFI_SPECIFICATION_MAJOR_REVISION<<16) | (EFI_SPECIFICATION_MINOR_REVISION)
+#define ACPI_EFI_SYSTEM_TABLE_SIGNATURE 0x5453595320494249
+#define ACPI_EFI_SYSTEM_TABLE_REVISION  (ACPI_EFI_SPECIFICATION_MAJOR_REVISION<<16) | (ACPI_EFI_SPECIFICATION_MINOR_REVISION)
 
-typedef struct _EFI_SYSTEM_TABLE {
-    EFI_TABLE_HEADER                Hdr;
+typedef struct _ACPI_EFI_SYSTEM_TABLE {
+    ACPI_EFI_TABLE_HEADER               Hdr;
 
-    CHAR16                          *FirmwareVendor;
-    UINT32                          FirmwareRevision;
+    CHAR16                              *FirmwareVendor;
+    UINT32                              FirmwareRevision;
 
-    EFI_HANDLE                      ConsoleInHandle;
-    SIMPLE_INPUT_INTERFACE          *ConIn;
+    ACPI_EFI_HANDLE                     ConsoleInHandle;
+    ACPI_SIMPLE_INPUT_INTERFACE         *ConIn;
 
-    EFI_HANDLE                      ConsoleOutHandle;
-    SIMPLE_TEXT_OUTPUT_INTERFACE    *ConOut;
+    ACPI_EFI_HANDLE                     ConsoleOutHandle;
+    ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE   *ConOut;
 
-    EFI_HANDLE                      StandardErrorHandle;
-    SIMPLE_TEXT_OUTPUT_INTERFACE    *StdErr;
+    ACPI_EFI_HANDLE                     StandardErrorHandle;
+    ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE   *StdErr;
 
-    EFI_RUNTIME_SERVICES            *RuntimeServices;
-    EFI_BOOT_SERVICES               *BootServices;
+    ACPI_EFI_RUNTIME_SERVICES           *RuntimeServices;
+    ACPI_EFI_BOOT_SERVICES              *BootServices;
 
-    UINTN                           NumberOfTableEntries;
-    EFI_CONFIGURATION_TABLE         *ConfigurationTable;
+    UINTN                               NumberOfTableEntries;
+    ACPI_EFI_CONFIGURATION_TABLE        *ConfigurationTable;
 
-} EFI_SYSTEM_TABLE;
+} ACPI_EFI_SYSTEM_TABLE;
 
 
 /* FILE abstraction */
 
 union acpi_efi_file {
-    struct _EFI_FILE_IO_INTERFACE File;
-    struct _SIMPLE_TEXT_OUTPUT_INTERFACE ConOut;
-    struct _SIMPLE_INPUT_INTERFACE ConIn;
+    struct _ACPI_EFI_FILE_IO_INTERFACE File;
+    struct _ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE ConOut;
+    struct _ACPI_SIMPLE_INPUT_INTERFACE ConIn;
 };
 
 
@@ -1022,10 +1023,10 @@ DivU64x32 (
 /*
  * EFI specific prototypes
  */
-EFI_STATUS
+ACPI_EFI_STATUS
 efi_main (
-    EFI_HANDLE              Image,
-    EFI_SYSTEM_TABLE        *SystemTab);
+    ACPI_EFI_HANDLE         Image,
+    ACPI_EFI_SYSTEM_TABLE   *SystemTab);
 
 int
 acpi_main (
@@ -1035,10 +1036,10 @@ acpi_main (
 
 #endif
 
-extern EFI_GUID AcpiGbl_LoadedImageProtocol;
-extern EFI_GUID AcpiGbl_TextInProtocol;
-extern EFI_GUID AcpiGbl_TextOutProtocol;
-extern EFI_GUID AcpiGbl_FileSystemProtocol;
-extern EFI_GUID AcpiGbl_GenericFileInfo;
+extern ACPI_EFI_GUID AcpiGbl_LoadedImageProtocol;
+extern ACPI_EFI_GUID AcpiGbl_TextInProtocol;
+extern ACPI_EFI_GUID AcpiGbl_TextOutProtocol;
+extern ACPI_EFI_GUID AcpiGbl_FileSystemProtocol;
+extern ACPI_EFI_GUID AcpiGbl_GenericFileInfo;
 
 #endif /* __ACEFIEX_H__ */
diff --git a/source/os_specific/service_layers/oseficlib.c b/source/os_specific/service_layers/oseficlib.c
index 69f92b6d1..43337c838 100644
--- a/source/os_specific/service_layers/oseficlib.c
+++ b/source/os_specific/service_layers/oseficlib.c
@@ -156,7 +156,7 @@ AcpiEfiConvertArgcv (
 static int
 AcpiEfiGetFileInfo (
     FILE                    *File,
-    EFI_FILE_INFO           **InfoPtr);
+    ACPI_EFI_FILE_INFO      **InfoPtr);
 
 static CHAR16 *
 AcpiEfiFlushFile (
@@ -169,12 +169,12 @@ AcpiEfiFlushFile (
 
 /* Local variables */
 
-static EFI_FILE_HANDLE      AcpiGbl_EfiCurrentVolume = NULL;
-EFI_GUID                    AcpiGbl_LoadedImageProtocol = LOADED_IMAGE_PROTOCOL;
-EFI_GUID                    AcpiGbl_TextInProtocol = SIMPLE_TEXT_INPUT_PROTOCOL;
-EFI_GUID                    AcpiGbl_TextOutProtocol = SIMPLE_TEXT_OUTPUT_PROTOCOL;
-EFI_GUID                    AcpiGbl_FileSystemProtocol = SIMPLE_FILE_SYSTEM_PROTOCOL;
-EFI_GUID                    AcpiGbl_GenericFileInfo = EFI_FILE_INFO_ID;
+static ACPI_EFI_FILE_HANDLE AcpiGbl_EfiCurrentVolume = NULL;
+ACPI_EFI_GUID               AcpiGbl_LoadedImageProtocol = ACPI_EFI_LOADED_IMAGE_PROTOCOL;
+ACPI_EFI_GUID               AcpiGbl_TextInProtocol = ACPI_SIMPLE_TEXT_INPUT_PROTOCOL;
+ACPI_EFI_GUID               AcpiGbl_TextOutProtocol = ACPI_SIMPLE_TEXT_OUTPUT_PROTOCOL;
+ACPI_EFI_GUID               AcpiGbl_FileSystemProtocol = ACPI_SIMPLE_FILE_SYSTEM_PROTOCOL;
+ACPI_EFI_GUID               AcpiGbl_GenericFileInfo = ACPI_EFI_FILE_INFO_ID;
 
 int                         errno = 0;
 
@@ -197,9 +197,9 @@ fopen (
     const char              *Path,
     const char              *Modes)
 {
-    EFI_STATUS              EfiStatus = EFI_SUCCESS;
+    ACPI_EFI_STATUS         EfiStatus = ACPI_EFI_SUCCESS;
     UINT64                  OpenModes;
-    EFI_FILE_HANDLE         EfiFile = NULL;
+    ACPI_EFI_FILE_HANDLE    EfiFile = NULL;
     CHAR16                  *Path16 = NULL;
     CHAR16                  *Pos16;
     const char              *Pos;
@@ -218,7 +218,7 @@ fopen (
      * Convert modes, EFI says the only 2 read/write modes are read-only,
      * read+write. Thus set default mode as read-only.
      */
-    OpenModes = EFI_FILE_MODE_READ;
+    OpenModes = ACPI_EFI_FILE_MODE_READ;
     switch (*Modes++)
     {
     case 'r':
@@ -227,12 +227,12 @@ fopen (
 
     case 'w':
 
-        OpenModes |= (EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE);
+        OpenModes |= (ACPI_EFI_FILE_MODE_WRITE | ACPI_EFI_FILE_MODE_CREATE);
         break;
 
     case 'a':
 
-        OpenModes |= (EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE);
+        OpenModes |= (ACPI_EFI_FILE_MODE_WRITE | ACPI_EFI_FILE_MODE_CREATE);
         IsAppend = TRUE;
         break;
 
@@ -248,7 +248,7 @@ fopen (
         {
         case '+':
 
-            OpenModes |= (EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE);
+            OpenModes |= (ACPI_EFI_FILE_MODE_WRITE | ACPI_EFI_FILE_MODE_CREATE);
             break;
 
         case 'b':
@@ -269,7 +269,7 @@ fopen (
     Path16 = ACPI_ALLOCATE_ZEROED ((Count + 1) * sizeof (CHAR16));
     if (!Path16)
     {
-        EfiStatus = EFI_BAD_BUFFER_SIZE;
+        EfiStatus = ACPI_EFI_BAD_BUFFER_SIZE;
         errno = ENOMEM;
         goto ErrorExit;
     }
@@ -296,7 +296,7 @@ fopen (
 
     EfiStatus = uefi_call_wrapper (AcpiGbl_EfiCurrentVolume->Open, 5,
         AcpiGbl_EfiCurrentVolume, &EfiFile, Path16, OpenModes, 0);
-    if (EFI_ERROR (EfiStatus))
+    if (ACPI_EFI_ERROR (EfiStatus))
     {
         fprintf (stderr, "EFI_FILE_HANDLE->Open() failure.\n");
         errno = ENOENT;
@@ -336,7 +336,7 @@ void
 fclose (
     FILE                    *File)
 {
-    EFI_FILE_HANDLE         EfiFile;
+    ACPI_EFI_FILE_HANDLE    EfiFile;
 
 
     if (File == stdin || File == stdout ||
@@ -344,7 +344,7 @@ fclose (
     {
         return;
     }
-    EfiFile = (EFI_FILE_HANDLE) File;
+    EfiFile = (ACPI_EFI_FILE_HANDLE) File;
     (void) uefi_call_wrapper (AcpiGbl_EfiCurrentVolume->Close, 1, EfiFile);
 
     return;
@@ -503,11 +503,11 @@ fread (
     FILE                    *File)
 {
     int                     Length = -EINVAL;
-    EFI_FILE_HANDLE         EfiFile;
-    SIMPLE_INPUT_INTERFACE  *In;
+    ACPI_EFI_FILE_HANDLE    EfiFile;
+    ACPI_SIMPLE_INPUT_INTERFACE *In;
     UINTN                   ReadSize;
-    EFI_STATUS              EfiStatus;
-    EFI_INPUT_KEY           Key;
+    ACPI_EFI_STATUS         EfiStatus;
+    ACPI_EFI_INPUT_KEY      Key;
     ACPI_SIZE               Pos = 0;
 
 
@@ -525,15 +525,15 @@ fread (
     }
     else if (File == stdin)
     {
-        In = ACPI_CAST_PTR (SIMPLE_INPUT_INTERFACE, File);
+        In = ACPI_CAST_PTR (ACPI_SIMPLE_INPUT_INTERFACE, File);
 
         while (Pos < ReadSize)
         {
 WaitKey:
             EfiStatus = uefi_call_wrapper (In->ReadKeyStroke, 2, In, &Key);
-            if (EFI_ERROR (EfiStatus))
+            if (ACPI_EFI_ERROR (EfiStatus))
             {
-                if (EfiStatus == EFI_NOT_READY)
+                if (EfiStatus == ACPI_EFI_NOT_READY)
                 {
                     goto WaitKey;
                 }
@@ -586,7 +586,7 @@ WaitKey:
     }
     else
     {
-        EfiFile = (EFI_FILE_HANDLE) File;
+        EfiFile = (ACPI_EFI_FILE_HANDLE) File;
         if (!EfiFile)
         {
             errno = EINVAL;
@@ -595,7 +595,7 @@ WaitKey:
 
         EfiStatus = uefi_call_wrapper (AcpiGbl_EfiCurrentVolume->Read, 3,
             EfiFile, &ReadSize, Buffer);
-        if (EFI_ERROR (EfiStatus))
+        if (ACPI_EFI_ERROR (EfiStatus))
         {
             fprintf (stderr, "EFI_FILE_HANDLE->Read() failure.\n");
             errno = EIO;
@@ -635,12 +635,12 @@ AcpiEfiFlushFile (
     CHAR16                  *Pos,
     BOOLEAN                 FlushAll)
 {
-    SIMPLE_TEXT_OUTPUT_INTERFACE *Out;
+    ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE *Out;
 
 
     if (File == stdout || File == stderr)
     {
-        Out = ACPI_CAST_PTR (SIMPLE_TEXT_OUTPUT_INTERFACE, File);
+        Out = ACPI_CAST_PTR (ACPI_SIMPLE_TEXT_OUTPUT_INTERFACE, File);
 
         if (FlushAll || Pos >= (End - 1))
         {
@@ -682,9 +682,9 @@ fwrite (
     CHAR16                  *End;
     CHAR16                  *Pos;
     int                     i, j;
-    EFI_FILE_HANDLE         EfiFile;
+    ACPI_EFI_FILE_HANDLE    EfiFile;
     UINTN                   WriteSize;
-    EFI_STATUS              EfiStatus;
+    ACPI_EFI_STATUS         EfiStatus;
 
 
     if (File == stdin)
@@ -718,7 +718,7 @@ fwrite (
     }
     else
     {
-        EfiFile = (EFI_FILE_HANDLE) File;
+        EfiFile = (ACPI_EFI_FILE_HANDLE) File;
         if (!EfiFile)
         {
             errno = EINVAL;
@@ -728,7 +728,7 @@ fwrite (
 
         EfiStatus = uefi_call_wrapper (AcpiGbl_EfiCurrentVolume->Write, 3,
             EfiFile, &WriteSize, Buffer);
-        if (EFI_ERROR (EfiStatus))
+        if (ACPI_EFI_ERROR (EfiStatus))
         {
             fprintf (stderr, "EFI_FILE_HANDLE->Write() failure.\n");
             errno = EIO;
@@ -759,12 +759,12 @@ ErrorExit:
 static int
 AcpiEfiGetFileInfo (
     FILE                    *File,
-    EFI_FILE_INFO           **InfoPtr)
+    ACPI_EFI_FILE_INFO      **InfoPtr)
 {
-    EFI_STATUS              EfiStatus = EFI_BUFFER_TOO_SMALL;
-    EFI_FILE_INFO           *Buffer = NULL;
-    UINTN                   BufferSize = SIZE_OF_EFI_FILE_INFO + 200;
-    EFI_FILE_HANDLE         EfiFile;
+    ACPI_EFI_STATUS         EfiStatus = ACPI_EFI_BUFFER_TOO_SMALL;
+    ACPI_EFI_FILE_INFO      *Buffer = NULL;
+    UINTN                   BufferSize = ACPI_EFI_FILE_INFO_SIZE + 200;
+    ACPI_EFI_FILE_HANDLE    EfiFile;
 
 
     if (!InfoPtr)
@@ -773,9 +773,9 @@ AcpiEfiGetFileInfo (
         return (-EINVAL);
     }
 
-    while (EfiStatus == EFI_BUFFER_TOO_SMALL)
+    while (EfiStatus == ACPI_EFI_BUFFER_TOO_SMALL)
     {
-        EfiFile = ACPI_CAST_PTR (EFI_FILE, File);
+        EfiFile = ACPI_CAST_PTR (ACPI_EFI_FILE_STRUCT, File);
         Buffer = AcpiOsAllocate (BufferSize);
         if (!Buffer)
         {
@@ -784,10 +784,10 @@ AcpiEfiGetFileInfo (
         }
         EfiStatus = uefi_call_wrapper (EfiFile->GetInfo, 4, EfiFile,
             &AcpiGbl_GenericFileInfo, &BufferSize, Buffer);
-        if (EFI_ERROR (EfiStatus))
+        if (ACPI_EFI_ERROR (EfiStatus))
         {
             AcpiOsFree (Buffer);
-            if (EfiStatus != EFI_BUFFER_TOO_SMALL)
+            if (EfiStatus != ACPI_EFI_BUFFER_TOO_SMALL)
             {
                 errno = EIO;
                 return (-EIO);
@@ -818,8 +818,8 @@ ftell (
 {
     long                    Offset = -1;
     UINT64                  Current;
-    EFI_STATUS              EfiStatus;
-    EFI_FILE_HANDLE         EfiFile;
+    ACPI_EFI_STATUS         EfiStatus;
+    ACPI_EFI_FILE_HANDLE    EfiFile;
 
 
     if (File == stdin || File == stdout || File == stderr)
@@ -828,11 +828,11 @@ ftell (
     }
     else
     {
-        EfiFile = ACPI_CAST_PTR (EFI_FILE, File);
+        EfiFile = ACPI_CAST_PTR (ACPI_EFI_FILE_STRUCT, File);
 
         EfiStatus = uefi_call_wrapper (EfiFile->GetPosition, 2,
             EfiFile, &Current);
-        if (EFI_ERROR (EfiStatus))
+        if (ACPI_EFI_ERROR (EfiStatus))
         {
             goto ErrorExit;
         }
@@ -867,12 +867,12 @@ fseek (
     long                    Offset,
     int                     From)
 {
-    EFI_FILE_INFO           *Info;
+    ACPI_EFI_FILE_INFO      *Info;
     int                     Error;
     ACPI_SIZE               Size;
     UINT64                  Current;
-    EFI_STATUS              EfiStatus;
-    EFI_FILE_HANDLE         EfiFile;
+    ACPI_EFI_STATUS         EfiStatus;
+    ACPI_EFI_FILE_HANDLE    EfiFile;
 
 
     if (File == stdin || File == stdout || File == stderr)
@@ -881,7 +881,7 @@ fseek (
     }
     else
     {
-        EfiFile = ACPI_CAST_PTR (EFI_FILE, File);
+        EfiFile = ACPI_CAST_PTR (ACPI_EFI_FILE_STRUCT, File);
         Error = AcpiEfiGetFileInfo (File, &Info);
         if (Error)
         {
@@ -894,7 +894,7 @@ fseek (
         {
             EfiStatus = uefi_call_wrapper (EfiFile->GetPosition, 2,
                 EfiFile, &Current);
-            if (EFI_ERROR (EfiStatus))
+            if (ACPI_EFI_ERROR (EfiStatus))
             {
                 errno = ERANGE;
                 return (-ERANGE);
@@ -912,7 +912,7 @@ fseek (
 
         EfiStatus = uefi_call_wrapper (EfiFile->SetPosition, 2,
             EfiFile, Current);
-        if (EFI_ERROR (EfiStatus))
+        if (ACPI_EFI_ERROR (EfiStatus))
         {
             errno = ERANGE;
             return (-ERANGE);
@@ -1172,18 +1172,18 @@ ErrorExit:
  *
  *****************************************************************************/
 
-EFI_STATUS
+ACPI_EFI_STATUS
 efi_main (
-    EFI_HANDLE              Image,
-    EFI_SYSTEM_TABLE        *SystemTab)
+    ACPI_EFI_HANDLE         Image,
+    ACPI_EFI_SYSTEM_TABLE   *SystemTab)
 {
-    EFI_LOADED_IMAGE        *Info;
-    EFI_STATUS              EfiStatus = EFI_SUCCESS;
+    ACPI_EFI_LOADED_IMAGE   *Info;
+    ACPI_EFI_STATUS         EfiStatus = ACPI_EFI_SUCCESS;
     int                     Error;
     int                     argc;
     char                    **argv = NULL;
     char                    *OptBuffer = NULL;
-    EFI_FILE_IO_INTERFACE   *Volume = NULL;
+    ACPI_EFI_FILE_IO_INTERFACE *Volume = NULL;
 
 
     /* Initialize global variables */
@@ -1200,7 +1200,7 @@ efi_main (
 
     EfiStatus = uefi_call_wrapper (BS->HandleProtocol, 3,
         Image, &AcpiGbl_LoadedImageProtocol, ACPI_CAST_PTR (VOID, &Info));
-    if (EFI_ERROR (EfiStatus))
+    if (ACPI_EFI_ERROR (EfiStatus))
     {
         fprintf (stderr,
             "EFI_BOOT_SERVICES->HandleProtocol(LoadedImageProtocol) failure.\n");
@@ -1209,7 +1209,7 @@ efi_main (
 
     EfiStatus = uefi_call_wrapper (BS->HandleProtocol, 3,
         Info->DeviceHandle, &AcpiGbl_FileSystemProtocol, (void **) &Volume);
-    if (EFI_ERROR (EfiStatus))
+    if (ACPI_EFI_ERROR (EfiStatus))
     {
         fprintf (stderr,
             "EFI_BOOT_SERVICES->HandleProtocol(FileSystemProtocol) failure.\n");
@@ -1217,7 +1217,7 @@ efi_main (
     }
     EfiStatus = uefi_call_wrapper (Volume->OpenVolume, 2,
         Volume, &AcpiGbl_EfiCurrentVolume);
-    if (EFI_ERROR (EfiStatus))
+    if (ACPI_EFI_ERROR (EfiStatus))
     {
         fprintf (stderr, "EFI_FILE_IO_INTERFACE->OpenVolume() failure.\n");
         return (EfiStatus);
@@ -1227,7 +1227,7 @@ efi_main (
         Info->LoadOptionsSize, &argc, &argv, &OptBuffer);
     if (Error)
     {
-        EfiStatus = EFI_DEVICE_ERROR;
+        EfiStatus = ACPI_EFI_DEVICE_ERROR;
         goto ErrorAlloc;
     }
 
diff --git a/source/os_specific/service_layers/osefixf.c b/source/os_specific/service_layers/osefixf.c
index 6ba45bb21..bc6c99f85 100644
--- a/source/os_specific/service_layers/osefixf.c
+++ b/source/os_specific/service_layers/osefixf.c
@@ -134,12 +134,12 @@ AeTableOverride (
 
 static BOOLEAN
 AcpiEfiCompareGuid (
-    EFI_GUID                *Guid1,
-    EFI_GUID                *Guid2);
+    ACPI_EFI_GUID           *Guid1,
+    ACPI_EFI_GUID           *Guid2);
 
 static ACPI_PHYSICAL_ADDRESS
 AcpiEfiGetRsdpViaGuid (
-    EFI_GUID                *Guid);
+    ACPI_EFI_GUID           *Guid);
 
 
 /******************************************************************************
@@ -157,8 +157,8 @@ AcpiEfiGetRsdpViaGuid (
 
 static BOOLEAN
 AcpiEfiCompareGuid (
-    EFI_GUID                *Guid1,
-    EFI_GUID                *Guid2)
+    ACPI_EFI_GUID           *Guid1,
+    ACPI_EFI_GUID           *Guid2)
 {
     INT32                   *g1;
     INT32                   *g2;
@@ -191,7 +191,7 @@ AcpiEfiCompareGuid (
 
 static ACPI_PHYSICAL_ADDRESS
 AcpiEfiGetRsdpViaGuid (
-    EFI_GUID                *Guid)
+    ACPI_EFI_GUID           *Guid)
 {
     ACPI_PHYSICAL_ADDRESS   Address = 0;
     int                     i;
@@ -228,8 +228,8 @@ AcpiOsGetRootPointer (
     void)
 {
     ACPI_PHYSICAL_ADDRESS   Address;
-    EFI_GUID                Guid10 = ACPI_TABLE_GUID;
-    EFI_GUID                Guid20 = ACPI_20_TABLE_GUID;
+    ACPI_EFI_GUID           Guid10 = ACPI_TABLE_GUID;
+    ACPI_EFI_GUID           Guid20 = ACPI_20_TABLE_GUID;
 
 
     Address = AcpiEfiGetRsdpViaGuid (&Guid20);
@@ -737,15 +737,15 @@ UINT64
 AcpiOsGetTimer (
     void)
 {
-    EFI_STATUS              EfiStatus;
-    EFI_TIME                EfiTime;
+    ACPI_EFI_STATUS         EfiStatus;
+    ACPI_EFI_TIME           EfiTime;
     int                     Year, Month, Day;
     int                     Hour, Minute, Second;
     UINT64                  Timer;
 
 
     EfiStatus = uefi_call_wrapper (RT->GetTime, 2, &EfiTime, NULL);
-    if (EFI_ERROR (EfiStatus))
+    if (ACPI_EFI_ERROR (EfiStatus))
     {
         return (-1);
     }
@@ -843,13 +843,13 @@ void *
 AcpiOsAllocate (
     ACPI_SIZE               Size)
 {
-    EFI_STATUS              EfiStatus;
+    ACPI_EFI_STATUS         EfiStatus;
     void                    *Mem;
 
 
     EfiStatus = uefi_call_wrapper (BS->AllocatePool, 3,
-        EfiLoaderData, Size, &Mem);
-    if (EFI_ERROR (EfiStatus))
+        AcpiEfiLoaderData, Size, &Mem);
+    if (ACPI_EFI_ERROR (EfiStatus))
     {
         fprintf (stderr,
             "EFI_BOOT_SERVICES->AllocatePool(EfiLoaderData) failure.\n");