InOsEmuPkg: Rename package to EmulatorPkg & Sec to Host

* Rename InOsEmuPkg to EmulatorPkg
* Rename Unix/Sec to Unix/Host

Signed-off-by: jljusten
Reviewed-by: andrewfish
Reviewed-by: geekboy15a

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@11918 6f19259b-4bc3-4df7-8a09-765794883524

EmulatorPkg/CpuRuntimeDxe/Cpu.c

@@ -0,0 +1,374 @@
+/*++ @file
+  Emu driver to produce CPU Architectural Protocol.
+  
+Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2011, Apple Inc. All rights reserved.
+This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution.  The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#include "CpuDriver.h"
+
+UINT64  mTimerPeriod;
+
+CPU_ARCH_PROTOCOL_PRIVATE mCpuTemplate = {
+  CPU_ARCH_PROT_PRIVATE_SIGNATURE,
+  NULL,
+  {
+    EmuFlushCpuDataCache,
+    EmuEnableInterrupt,
+    EmuDisableInterrupt,
+    EmuGetInterruptState,
+    EmuInit,
+    EmuRegisterInterruptHandler,
+    EmuGetTimerValue,
+    EmuSetMemoryAttributes,
+    0,
+    4
+  },
+  {
+    {
+      CpuMemoryServiceRead,
+      CpuMemoryServiceWrite
+    },
+    {
+      CpuIoServiceRead,
+      CpuIoServiceWrite
+    }
+  },
+  TRUE
+};
+
+#define EFI_CPU_DATA_MAXIMUM_LENGTH 0x100
+
+
+
+//
+// Service routines for the driver
+//
+EFI_STATUS
+EFIAPI
+EmuFlushCpuDataCache (
+  IN EFI_CPU_ARCH_PROTOCOL  *This,
+  IN EFI_PHYSICAL_ADDRESS   Start,
+  IN UINT64                 Length,
+  IN EFI_CPU_FLUSH_TYPE     FlushType
+  )
+{
+  if (FlushType == EfiCpuFlushTypeWriteBackInvalidate) {
+    //
+    // Only WB flush is supported. We actually need do nothing on Emu emulator
+    // environment. Classify this to follow EFI spec
+    //
+    return EFI_SUCCESS;
+  }
+  //
+  // Other flush types are not supported by Emu emulator
+  //
+  return EFI_UNSUPPORTED;
+}
+
+EFI_STATUS
+EFIAPI
+EmuEnableInterrupt (
+  IN EFI_CPU_ARCH_PROTOCOL  *This
+  )
+{
+  CPU_ARCH_PROTOCOL_PRIVATE *Private;
+
+  Private                 = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This);
+  Private->InterruptState = TRUE;
+  gEmuThunk->EnableInterrupt ();
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+EFIAPI
+EmuDisableInterrupt (
+  IN EFI_CPU_ARCH_PROTOCOL  *This
+  )
+{
+  CPU_ARCH_PROTOCOL_PRIVATE *Private;
+
+  Private                 = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This);
+  Private->InterruptState = FALSE;
+  gEmuThunk->DisableInterrupt ();
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+EFIAPI
+EmuGetInterruptState (
+  IN EFI_CPU_ARCH_PROTOCOL  *This,
+  OUT BOOLEAN               *State
+  )
+{
+  CPU_ARCH_PROTOCOL_PRIVATE *Private;
+
+  if (State == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  Private = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This);
+  *State  = Private->InterruptState;
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+EFIAPI
+EmuInit (
+  IN EFI_CPU_ARCH_PROTOCOL  *This,
+  IN EFI_CPU_INIT_TYPE      InitType
+  )
+{
+  CPU_ARCH_PROTOCOL_PRIVATE *Private;
+
+  Private = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This);
+  return EFI_UNSUPPORTED;
+}
+
+EFI_STATUS
+EFIAPI
+EmuRegisterInterruptHandler (
+  IN EFI_CPU_ARCH_PROTOCOL      *This,
+  IN EFI_EXCEPTION_TYPE         InterruptType,
+  IN EFI_CPU_INTERRUPT_HANDLER  InterruptHandler
+  )
+{
+  CPU_ARCH_PROTOCOL_PRIVATE *Private;
+
+  //
+  // Do parameter checking for EFI spec conformance
+  //
+  if (InterruptType < 0 || InterruptType > 0xff) {
+    return EFI_UNSUPPORTED;
+  }
+  //
+  // Do nothing for Emu emulation
+  //
+  Private = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This);
+  return EFI_UNSUPPORTED;
+}
+
+EFI_STATUS
+EFIAPI
+EmuGetTimerValue (
+  IN  EFI_CPU_ARCH_PROTOCOL *This,
+  IN  UINT32                TimerIndex,
+  OUT UINT64                *TimerValue,
+  OUT UINT64                *TimerPeriod OPTIONAL
+  )
+{
+  if (TimerValue == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  if (TimerIndex != 0) {
+    return EFI_INVALID_PARAMETER;
+  }
+  
+  *TimerValue = gEmuThunk->QueryPerformanceCounter ();
+  
+  if (TimerPeriod != NULL) {
+    *TimerPeriod = mTimerPeriod;
+  } 
+
+  return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+EFIAPI
+EmuSetMemoryAttributes (
+  IN EFI_CPU_ARCH_PROTOCOL  *This,
+  IN EFI_PHYSICAL_ADDRESS   BaseAddress,
+  IN UINT64                 Length,
+  IN UINT64                 Attributes
+  )
+{
+  CPU_ARCH_PROTOCOL_PRIVATE *Private;
+
+  //
+  // Check for invalid parameter for Spec conformance
+  //
+  if (Length == 0) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // Do nothing for Nt32 emulation
+  //
+  Private = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This);
+  return EFI_UNSUPPORTED;
+}
+
+
+
+/**
+  Logs SMBIOS record.
+
+  @param  Smbios   Pointer to SMBIOS protocol instance.
+  @param  Buffer   Pointer to the data buffer.
+
+**/
+VOID
+LogSmbiosData (
+  IN  EFI_SMBIOS_PROTOCOL        *Smbios,
+  IN  UINT8                      *Buffer
+  )
+{
+  EFI_STATUS         Status;
+  EFI_SMBIOS_HANDLE  SmbiosHandle;
+  
+  SmbiosHandle = 0;
+  Status = Smbios->Add (
+                     Smbios,
+                     NULL,
+                     &SmbiosHandle,
+                     (EFI_SMBIOS_TABLE_HEADER*)Buffer
+                     );
+  ASSERT_EFI_ERROR (Status);
+}
+
+VOID
+CpuUpdateSmbios (
+  VOID
+  )
+{
+  EFI_STATUS                  Status;
+  UINT32                      TotalSize;
+  EFI_SMBIOS_PROTOCOL         *Smbios;
+  EFI_HII_HANDLE              HiiHandle;
+  STRING_REF                  Token;
+  UINTN                       CpuVerStrLen;
+  EFI_STRING                  CpuVerStr;
+  SMBIOS_TABLE_TYPE4          *SmbiosRecord;
+  CHAR8                       *OptionalStrStart;
+
+  //
+  // Locate Smbios protocol.
+  //
+  Status = gBS->LocateProtocol (&gEfiSmbiosProtocolGuid, NULL, (VOID **)&Smbios);
+  
+  if (EFI_ERROR (Status)) {
+    return;
+  }
+
+  //
+  // Initialize strings to HII database
+  //
+  HiiHandle = HiiAddPackages (
+                &gEfiCallerIdGuid,
+                NULL,
+                CpuStrings,
+                NULL
+                );
+  ASSERT (HiiHandle != NULL);
+
+  Token  = STRING_TOKEN (STR_PROCESSOR_VERSION);
+  CpuVerStr = HiiGetPackageString(&gEfiCallerIdGuid, Token, NULL);
+  CpuVerStrLen = StrLen(CpuVerStr);
+  ASSERT (CpuVerStrLen <= SMBIOS_STRING_MAX_LENGTH);
+
+  TotalSize = sizeof(SMBIOS_TABLE_TYPE4) + CpuVerStrLen + 1 + 1;
+  SmbiosRecord = AllocatePool(TotalSize);
+  ZeroMem(SmbiosRecord, TotalSize);
+
+  SmbiosRecord->Hdr.Type = EFI_SMBIOS_TYPE_PROCESSOR_INFORMATION;
+  SmbiosRecord->Hdr.Length = sizeof (SMBIOS_TABLE_TYPE4);
+  //
+  // Make handle chosen by smbios protocol.add automatically.
+  //
+  SmbiosRecord->Hdr.Handle = 0;  
+  //
+  // Processor version is the 1st string.
+  //
+  SmbiosRecord->ProcessorVersion = 1;
+  //
+  // Store CPU frequency data record to data hub - It's an emulator so make up a value
+  //
+  SmbiosRecord->CurrentSpeed  = 1234;
+
+  OptionalStrStart = (CHAR8 *)(SmbiosRecord + 1);
+  UnicodeStrToAsciiStr(CpuVerStr, OptionalStrStart);
+
+  //
+  // Now we have got the full smbios record, call smbios protocol to add this record.
+  //
+  LogSmbiosData(Smbios, (UINT8 *) SmbiosRecord);
+  FreePool (SmbiosRecord);
+}
+
+
+
+/**
+  Callback function for idle events.
+ 
+  @param  Event                 Event whose notification function is being invoked.
+  @param  Context               The pointer to the notification function's context,
+                                which is implementation-dependent.
+
+**/
+VOID
+EFIAPI
+IdleLoopEventCallback (
+  IN EFI_EVENT                Event,
+  IN VOID                     *Context
+  )
+{
+  gEmuThunk->CpuSleep ();
+}
+
+
+EFI_STATUS
+EFIAPI
+InitializeCpu (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_STATUS    Status;
+  UINT64        Frequency;
+  EFI_EVENT     IdleLoopEvent;
+
+  //
+  // Retrieve the frequency of the performance counter in Hz.
+  //  
+  Frequency = gEmuThunk->QueryPerformanceFrequency ();
+  
+  //
+  // Convert frequency in Hz to a clock period in femtoseconds.
+  //
+  mTimerPeriod = DivU64x64Remainder (1000000000000000ULL, Frequency, NULL);
+
+  CpuUpdateSmbios ();
+  
+  CpuMpServicesInit ();
+  
+  Status = gBS->CreateEventEx (
+                  EVT_NOTIFY_SIGNAL,
+                  TPL_NOTIFY,
+                  IdleLoopEventCallback,
+                  NULL,
+                  &gIdleLoopEventGuid,
+                  &IdleLoopEvent
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+
+  Status = gBS->InstallMultipleProtocolInterfaces (
+                  &mCpuTemplate.Handle,
+                  &gEfiCpuArchProtocolGuid,   &mCpuTemplate.Cpu,
+                  &gEfiCpuIo2ProtocolGuid,    &mCpuTemplate.CpuIo,
+                  NULL
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}

EmulatorPkg/CpuRuntimeDxe/Cpu.inf

@@ -0,0 +1,76 @@
+## @file
+# Component description file for Cpu module.
+#
+# This CPU module abstracts the interrupt subsystem of a platform and the CPU-specific setjump-long pair.
+#
+# Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+#
+#  This program and the accompanying materials
+#  are licensed and made available under the terms and conditions of the BSD License
+#  which accompanies this distribution. The full text of the license may be found at
+#  http://opensource.org/licenses/bsd-license.php
+#
+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = Cpu
+  FILE_GUID                      = f3794b60-8985-11db-8e53-0040d02b1835
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+
+  ENTRY_POINT                    = InitializeCpu
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  CpuIo.c
+  Cpu.c
+  CpuDriver.h
+  Strings.uni
+  MpService.c
+  
+
+[Packages]
+  MdePkg/MdePkg.dec
+  MdeModulePkg/MdeModulePkg.dec
+  IntelFrameworkPkg/IntelFrameworkPkg.dec
+  EmulatorPkg/EmulatorPkg.dec
+
+
+[LibraryClasses]
+  UefiBootServicesTableLib
+  MemoryAllocationLib
+  BaseMemoryLib
+  UefiDriverEntryPoint
+  UefiLib
+  HiiLib
+  DebugLib
+  BaseLib
+  EmuThunkLib
+  PcdLib
+
+[Protocols]
+  gEmuIoThunkProtocolGuid                       # PROTOCOL_NOTIFY SOMETIMES_CONSUMED
+  gEfiSmbiosProtocolGuid                        # PROTOCOL SOMETIMES_CONSUMED
+  gEfiHiiProtocolGuid                           # PROTOCOL SOMETIMES_CONSUMED
+  gEfiCpuIo2ProtocolGuid                        # PROTOCOL ALWAYS_PRODUCED
+  gEfiCpuArchProtocolGuid                       # PROTOCOL ALWAYS_PRODUCED
+  gEmuThreadThunkProtocolGuid
+  gEfiMpServiceProtocolGuid
+
+[Guids]
+  gIdleLoopEventGuid                            ## CONSUMES ## GUID
+
+[Pcd]
+  gEmulatorPkgTokenSpaceGuid.PcdEmuMpServicesPollingInterval
+
+[Depex]
+  gEfiSmbiosProtocolGuid

EmulatorPkg/CpuRuntimeDxe/CpuDriver.h

@@ -0,0 +1,246 @@
+/*++ @file
+
+Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2011, Apple Inc. All rights reserved.
+
+This program and the accompanying materials                          
+are licensed and made available under the terms and conditions of the BSD License         
+which accompanies this distribution.  The full text of the license may be found at        
+http://opensource.org/licenses/bsd-license.php                                            
+                                                                                          
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
+
+**/
+
+#ifndef _CPU_ARCHITECTURAL_PROTOCOL_DRIVER_H_
+#define _CPU_ARCHITECTURAL_PROTOCOL_DRIVER_H_
+
+
+#include <FrameworkDxe.h>
+#include <IndustryStandard/SmBios.h>
+
+#include <Protocol/Cpu.h>
+#include <Protocol/Smbios.h>
+#include <Protocol/FrameworkHii.h>
+#include <Protocol/MpService.h>
+#include <Protocol/EmuThread.h>
+#include <Protocol/CpuIo2.h>
+
+#include <Guid/DataHubRecords.h>
+#include <Guid/IdleLoopEvent.h>
+
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/HiiLib.h>
+#include <Library/UefiDriverEntryPoint.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/EmuThunkLib.h>
+#include <Library/UefiLib.h>
+#include <Library/PcdLib.h>
+
+
+extern UINT8  CpuStrings[];
+
+//
+// Internal Data Structures
+//
+#define CPU_ARCH_PROT_PRIVATE_SIGNATURE SIGNATURE_32 ('c', 'a', 'p', 'd')
+
+typedef struct {
+  UINTN                 Signature;
+  EFI_HANDLE            Handle;
+
+  EFI_CPU_ARCH_PROTOCOL Cpu;
+  EFI_CPU_IO2_PROTOCOL  CpuIo;
+
+  //
+  // Local Data for CPU interface goes here
+  //
+  BOOLEAN               InterruptState;
+
+} CPU_ARCH_PROTOCOL_PRIVATE;
+
+#define CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS(a) \
+  CR (a, \
+      CPU_ARCH_PROTOCOL_PRIVATE, \
+      Cpu, \
+      CPU_ARCH_PROT_PRIVATE_SIGNATURE \
+      )
+
+
+
+typedef enum {
+  CPU_STATE_IDLE,
+  CPU_STATE_BLOCKED,
+  CPU_STATE_READY,
+  CPU_STATE_BUSY,
+  CPU_STATE_FINISHED
+} PROCESSOR_STATE;
+
+
+//
+// Define Individual Processor Data block.
+//
+typedef struct {
+  EFI_PROCESSOR_INFORMATION   Info;
+  EFI_AP_PROCEDURE            Procedure;
+  VOID                        *Parameter;
+  VOID                        *StateLock;
+  VOID                        *ProcedureLock;
+  PROCESSOR_STATE             State;
+  EFI_EVENT                   CheckThisAPEvent;   
+} PROCESSOR_DATA_BLOCK;
+
+
+//
+// Define MP data block which consumes individual processor block.
+//
+typedef struct {
+  UINTN                       NumberOfProcessors;
+  UINTN                       NumberOfEnabledProcessors;
+  EFI_EVENT                   CheckAllAPsEvent;
+  EFI_EVENT                   WaitEvent;
+  UINTN                       FinishCount;
+  UINTN                       StartCount;
+  EFI_AP_PROCEDURE            Procedure;
+  VOID                        *ProcedureArgument;
+  BOOLEAN                     SingleThread;
+  UINTN                       StartedNumber;
+  PROCESSOR_DATA_BLOCK        *ProcessorData;
+  UINTN                       Timeout;
+  UINTN                       *FailedList;
+  UINTN                       FailedListIndex;
+  BOOLEAN                     TimeoutActive;
+} MP_SYSTEM_DATA;
+
+
+
+
+
+EFI_STATUS
+EFIAPI
+CpuMemoryServiceRead (
+  IN  EFI_CPU_IO2_PROTOCOL              *This,
+  IN  EFI_CPU_IO_PROTOCOL_WIDTH         Width,
+  IN  UINT64                            Address,
+  IN  UINTN                             Count,
+  IN  OUT VOID                          *Buffer
+  );
+
+EFI_STATUS
+EFIAPI
+CpuMemoryServiceWrite (
+  IN EFI_CPU_IO2_PROTOCOL               *This,
+  IN  EFI_CPU_IO_PROTOCOL_WIDTH         Width,
+  IN  UINT64                            Address,
+  IN  UINTN                             Count,
+  IN  OUT VOID                          *Buffer
+  );
+
+EFI_STATUS
+EFIAPI
+CpuIoServiceRead (
+  IN EFI_CPU_IO2_PROTOCOL               *This,
+  IN  EFI_CPU_IO_PROTOCOL_WIDTH         Width,
+  IN  UINT64                            UserAddress,
+  IN  UINTN                             Count,
+  IN  OUT VOID                          *UserBuffer
+  );
+
+EFI_STATUS
+EFIAPI
+CpuIoServiceWrite (
+  IN EFI_CPU_IO2_PROTOCOL               *This,
+  IN  EFI_CPU_IO_PROTOCOL_WIDTH         Width,
+  IN  UINT64                            UserAddress,
+  IN  UINTN                             Count,
+  IN  OUT VOID                          *UserBuffer
+  );
+
+EFI_STATUS
+EFIAPI
+InitializeCpu (
+  IN EFI_HANDLE        ImageHandle,
+  IN EFI_SYSTEM_TABLE  *SystemTable
+  );
+
+EFI_STATUS
+EFIAPI
+EmuFlushCpuDataCache (
+  IN EFI_CPU_ARCH_PROTOCOL  *This,
+  IN EFI_PHYSICAL_ADDRESS   Start,
+  IN UINT64                 Length,
+  IN EFI_CPU_FLUSH_TYPE     FlushType
+  );
+
+EFI_STATUS
+EFIAPI
+EmuEnableInterrupt (
+  IN EFI_CPU_ARCH_PROTOCOL  *This
+  );
+
+EFI_STATUS
+EFIAPI
+EmuDisableInterrupt (
+  IN EFI_CPU_ARCH_PROTOCOL  *This
+  );
+
+EFI_STATUS
+EFIAPI
+EmuGetInterruptState (
+  IN EFI_CPU_ARCH_PROTOCOL  *This,
+  OUT BOOLEAN               *State
+  );
+
+EFI_STATUS
+EFIAPI
+EmuInit (
+  IN EFI_CPU_ARCH_PROTOCOL  *This,
+  IN EFI_CPU_INIT_TYPE      InitType
+  );
+
+EFI_STATUS
+EFIAPI
+EmuRegisterInterruptHandler (
+  IN EFI_CPU_ARCH_PROTOCOL      *This,
+  IN EFI_EXCEPTION_TYPE         InterruptType,
+  IN EFI_CPU_INTERRUPT_HANDLER  InterruptHandler
+  );
+
+EFI_STATUS
+EFIAPI
+EmuGetTimerValue (
+  IN  EFI_CPU_ARCH_PROTOCOL *This,
+  IN  UINT32                TimerIndex,
+  OUT UINT64                *TimerValue,
+  OUT UINT64                *TimerPeriod OPTIONAL
+  );
+
+EFI_STATUS
+EFIAPI
+EmuSetMemoryAttributes (
+  IN EFI_CPU_ARCH_PROTOCOL  *This,
+  IN EFI_PHYSICAL_ADDRESS   BaseAddress,
+  IN UINT64                 Length,
+  IN UINT64                 Attributes
+  );
+
+EFI_STATUS
+CpuMpServicesInit (
+  VOID
+  );
+
+EFI_STATUS
+EFIAPI
+CpuMpServicesWhoAmI (
+  IN EFI_MP_SERVICES_PROTOCOL  *This,
+  OUT UINTN                    *ProcessorNumber
+  );
+
+extern EFI_MP_SERVICES_PROTOCOL  mMpSercicesTemplate;
+
+
+#endif

EmulatorPkg/CpuRuntimeDxe/CpuIo.c

@@ -0,0 +1,333 @@
+/*++ @file
+  This is the code that publishes the CPU I/O Protocol.
+  The intent herein is to have a single I/O service that can load
+  as early as possible, extend into runtime, and be layered upon by 
+  the implementations of architectural protocols and the PCI Root
+  Bridge I/O Protocol.
+
+
+Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2011, Apple Inc. All rights reserved.
+This program and the accompanying materials                          
+are licensed and made available under the terms and conditions of the BSD License         
+which accompanies this distribution.  The full text of the license may be found at        
+http://opensource.org/licenses/bsd-license.php                                            
+                                                                                          
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
+
+**/
+
+#include <FrameworkDxe.h>
+#include <Protocol/Cpu.h>
+#include <Protocol/DataHub.h>
+#include <Guid/DataHubRecords.h>
+#include <Protocol/CpuIo2.h>
+#include <Protocol/FrameworkHii.h>
+
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/HiiLib.h>
+#include <Library/UefiLib.h>
+#include <Library/UefiDriverEntryPoint.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <CpuDriver.h>
+
+#define IA32_MAX_IO_ADDRESS   0xFFFF
+#define IA32_MAX_MEM_ADDRESS  0xFFFFFFFF
+
+EFI_STATUS
+CpuIoCheckAddressRange (
+  IN  EFI_CPU_IO_PROTOCOL_WIDTH         Width,
+  IN  UINT64                            Address,
+  IN  UINTN                             Count,
+  IN  VOID                              *Buffer,
+  IN  UINT64                            Limit
+  );
+
+EFI_STATUS
+EFIAPI
+CpuMemoryServiceRead (
+  IN  EFI_CPU_IO2_PROTOCOL              *This,
+  IN  EFI_CPU_IO_PROTOCOL_WIDTH         Width,
+  IN  UINT64                            Address,
+  IN  UINTN                             Count,
+  IN  OUT VOID                          *Buffer
+  )
+/*++
+
+Routine Description:
+
+  Perform the Memory Access Read service for the CPU I/O Protocol
+
+Arguments:
+
+  Pointer to an instance of the CPU I/O Protocol
+  Width of the Memory Access
+  Address of the Memory access
+  Count of the number of accesses to perform
+  Pointer to the buffer to read or write from memory
+
+Returns:
+
+  Status
+
+  EFI_SUCCESS             - The data was read from or written to the EFI 
+                            System.
+  EFI_INVALID_PARAMETER   - Width is invalid for this EFI System.
+  EFI_INVALID_PARAMETER   - Buffer is NULL.
+  EFI_UNSUPPORTED         - The Buffer is not aligned for the given Width.
+  EFI_UNSUPPORTED         - The address range specified by Address, Width, 
+                            and Count is not valid for this EFI System.
+
+**/
+{
+  EFI_STATUS  Status;
+
+  if (!Buffer) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  Status = CpuIoCheckAddressRange (Width, Address, Count, Buffer, IA32_MAX_MEM_ADDRESS);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Do nothing for Nt32 version
+  //
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+EFIAPI
+CpuMemoryServiceWrite (
+  IN EFI_CPU_IO2_PROTOCOL               *This,
+  IN  EFI_CPU_IO_PROTOCOL_WIDTH         Width,
+  IN  UINT64                            Address,
+  IN  UINTN                             Count,
+  IN  OUT VOID                          *Buffer
+  )
+/*++
+
+Routine Description:
+
+  Perform the Memory Access Read service for the CPU I/O Protocol
+
+Arguments:
+
+  Pointer to an instance of the CPU I/O Protocol
+  Width of the Memory Access
+  Address of the Memory access
+  Count of the number of accesses to perform
+  Pointer to the buffer to read or write from memory
+
+Returns:
+
+  Status
+
+  EFI_SUCCESS             - The data was read from or written to the EFI System.
+  EFI_INVALID_PARAMETER   - Width is invalid for this EFI System.
+  EFI_INVALID_PARAMETER   - Buffer is NULL.
+  EFI_UNSUPPORTED         - The Buffer is not aligned for the given Width.
+  EFI_UNSUPPORTED         - The address range specified by Address, Width, and 
+                            Count is not valid for this EFI System.
+
+**/
+{
+  EFI_STATUS  Status;
+
+  if (!Buffer) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  Status = CpuIoCheckAddressRange (Width, Address, Count, Buffer, IA32_MAX_MEM_ADDRESS);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Do nothing for Nt32 version
+  //
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+EFIAPI
+CpuIoServiceRead (
+  IN EFI_CPU_IO2_PROTOCOL               *This,
+  IN  EFI_CPU_IO_PROTOCOL_WIDTH         Width,
+  IN  UINT64                            UserAddress,
+  IN  UINTN                             Count,
+  IN  OUT VOID                          *UserBuffer
+  )
+/*++
+
+Routine Description:
+  
+  This is the service that implements the I/O read
+
+Arguments:
+
+  Pointer to an instance of the CPU I/O Protocol
+  Width of the Memory Access
+  Address of the I/O access
+  Count of the number of accesses to perform
+  Pointer to the buffer to read or write from I/O space
+
+Returns:
+
+  Status
+  EFI_SUCCESS             - The data was read from or written to the EFI System.
+  EFI_INVALID_PARAMETER   - Width is invalid for this EFI System.
+  EFI_INVALID_PARAMETER   - Buffer is NULL.
+  EFI_UNSUPPORTED         - The Buffer is not aligned for the given Width.
+  EFI_UNSUPPORTED         - The address range specified by Address, Width, and 
+                            Count is not valid for this EFI System.
+**/
+{
+  UINTN       Address;
+  EFI_STATUS  Status;
+
+  if (!UserBuffer) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  Address = (UINTN) UserAddress;
+
+  if (Width >= EfiCpuIoWidthMaximum) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  Status = CpuIoCheckAddressRange (Width, Address, Count, UserBuffer, IA32_MAX_IO_ADDRESS);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Do nothing for Nt32 version
+  //
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+EFIAPI
+CpuIoServiceWrite (
+  IN EFI_CPU_IO2_PROTOCOL               *This,
+  IN  EFI_CPU_IO_PROTOCOL_WIDTH         Width,
+  IN  UINT64                            UserAddress,
+  IN  UINTN                             Count,
+  IN  OUT VOID                          *UserBuffer
+  )
+/*++
+
+Routine Description:
+
+  
+  This is the service that implements the I/O Write
+
+Arguments:
+
+  Pointer to an instance of the CPU I/O Protocol
+  Width of the Memory Access
+  Address of the I/O access
+  Count of the number of accesses to perform
+  Pointer to the buffer to read or write from I/O space
+
+Returns:
+
+  Status
+
+  Status
+  EFI_SUCCESS             - The data was read from or written to the EFI System.
+  EFI_INVALID_PARAMETER   - Width is invalid for this EFI System.
+  EFI_INVALID_PARAMETER   - Buffer is NULL.
+  EFI_UNSUPPORTED         - The Buffer is not aligned for the given Width.
+  EFI_UNSUPPORTED         - The address range specified by Address, Width, and 
+                            Count is not valid for this EFI System.
+
+**/
+{
+  UINTN       Address;
+  EFI_STATUS  Status;
+
+  if (!UserBuffer) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  Address = (UINTN) UserAddress;
+
+  if (Width >= EfiCpuIoWidthMaximum) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  Status = CpuIoCheckAddressRange (Width, Address, Count, UserBuffer, IA32_MAX_IO_ADDRESS);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Do nothing for Nt32 version
+  //
+  return EFI_SUCCESS;
+}
+
+
+/*++
+
+Routine Description:
+
+Arguments:
+
+  Width   - TODO: add argument description
+  Address - TODO: add argument description
+  Count   - TODO: add argument description
+  Buffer  - TODO: add argument description
+  Limit   - TODO: add argument description
+
+Returns:
+
+  EFI_UNSUPPORTED - TODO: Add description for return value
+  EFI_UNSUPPORTED - TODO: Add description for return value
+  EFI_UNSUPPORTED - TODO: Add description for return value
+  EFI_SUCCESS - TODO: Add description for return value
+
+**/
+EFI_STATUS
+CpuIoCheckAddressRange (
+  IN  EFI_CPU_IO_PROTOCOL_WIDTH         Width,
+  IN  UINT64                            Address,
+  IN  UINTN                             Count,
+  IN  VOID                              *Buffer,
+  IN  UINT64                            Limit
+  )
+{
+  UINTN AlignMask;
+
+  if (Address > Limit) {
+    return EFI_UNSUPPORTED;
+  }
+
+  //
+  // For FiFo type, the target address won't increase during the access, so treat count as 1
+  //
+  if (Width >= EfiCpuIoWidthFifoUint8 && Width <= EfiCpuIoWidthFifoUint64) {
+    Count = 1;
+  }
+
+  Width = Width & 0x03;
+  if (Address - 1 + (1 << Width) * Count > Limit) {
+    return EFI_UNSUPPORTED;
+  }
+
+  AlignMask = (1 << Width) - 1;
+  if ((UINTN) Buffer & AlignMask) {
+    return EFI_UNSUPPORTED;
+  }
+
+  return EFI_SUCCESS;
+}
+
+