EmulatorPkg/CpuRuntimeDxe/Cpu.c - third_party/edk2 - Git at Google

 /*++ @file
   Emu driver to produce CPU Architectural Protocol.

 Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 Portions copyright (c) 2011 - 2012, 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

 SMBIOS_TABLE_TYPE4 mCpuSmbiosType4 = {
   { EFI_SMBIOS_TYPE_PROCESSOR_INFORMATION, sizeof (SMBIOS_TABLE_TYPE4), 0},
   1,                    // Socket String
   ProcessorOther,       // ProcessorType;          ///< The enumeration value from PROCESSOR_TYPE_DATA.
   ProcessorFamilyOther, // ProcessorFamily;        ///< The enumeration value from PROCESSOR_FAMILY_DATA.
   2,                    // ProcessorManufacture String;
   {                     // ProcessorId;
     {  // PROCESSOR_SIGNATURE
       0, //  ProcessorSteppingId:4;
       0, //  ProcessorModel:     4;
       0, //  ProcessorFamily:    4;
       0, //  ProcessorType:      2;
       0, //  ProcessorReserved1: 2;
       0, //  ProcessorXModel:    4;
       0, //  ProcessorXFamily:   8;
       0, //  ProcessorReserved2: 4;
     },
     {  // PROCESSOR_FEATURE_FLAGS
       0, //  ProcessorFpu       :1;
       0, //  ProcessorVme       :1;
       0, //  ProcessorDe        :1;
       0, //  ProcessorPse       :1;
       0, //  ProcessorTsc       :1;
       0, //  ProcessorMsr       :1;
       0, //  ProcessorPae       :1;
       0, //  ProcessorMce       :1;
       0, //  ProcessorCx8       :1;
       0, //  ProcessorApic      :1;
       0, //  ProcessorReserved1 :1;
       0, //  ProcessorSep       :1;
       0, //  ProcessorMtrr      :1;
       0, //  ProcessorPge       :1;
       0, //  ProcessorMca       :1;
       0, //  ProcessorCmov      :1;
       0, //  ProcessorPat       :1;
       0, //  ProcessorPse36     :1;
       0, //  ProcessorPsn       :1;
       0, //  ProcessorClfsh     :1;
       0, //  ProcessorReserved2 :1;
       0, //  ProcessorDs        :1;
       0, //  ProcessorAcpi      :1;
       0, //  ProcessorMmx       :1;
       0, //  ProcessorFxsr      :1;
       0, //  ProcessorSse       :1;
       0, //  ProcessorSse2      :1;
       0, //  ProcessorSs        :1;
       0, //  ProcessorReserved3 :1;
       0, //  ProcessorTm        :1;
       0, //  ProcessorReserved4 :2;
     }
   },
   3,                    // ProcessorVersion String;
   {                     // Voltage;
     1,  // ProcessorVoltageCapability5V        :1;
     1,  // ProcessorVoltageCapability3_3V      :1;
     1,  // ProcessorVoltageCapability2_9V      :1;
     0,  // ProcessorVoltageCapabilityReserved  :1; ///< Bit 3, must be zero.
     0,  // ProcessorVoltageReserved            :3; ///< Bits 4-6, must be zero.
     0   // ProcessorVoltageIndicateLegacy      :1;
   },
   0,                      // ExternalClock;
   0,                      // MaxSpeed;
   0,                      // CurrentSpeed;
   0x41,                   // Status;
   ProcessorUpgradeOther,  // ProcessorUpgrade;      ///< The enumeration value from PROCESSOR_UPGRADE.
   0,                      // L1CacheHandle;
   0,                      // L2CacheHandle;
   0,                      // L3CacheHandle;
   4,                      // SerialNumber;
   5,                      // AssetTag;
   6,                      // PartNumber;
   0,                      // CoreCount;
   0,                      // EnabledCoreCount;
   0,                      // ThreadCount;
   0,                      // ProcessorCharacteristics;
   0,                      // ProcessorFamily2;
 };

 CHAR8 *mCpuSmbiosType4Strings[] = {
   "Socket",
   "http://www.tianocore.org/edk2/",
   "Emulated Processor",
   "1.0",
   "1.0",
   "1.0",
   NULL
 };


 /**
   Create SMBIOS record.

   Converts a fixed SMBIOS structure and an array of pointers to strings into
   an SMBIOS record where the strings are cat'ed on the end of the fixed record
   and terminated via a double NULL and add to SMBIOS table.

   SMBIOS_TABLE_TYPE32 gSmbiosType12 = {
     { EFI_SMBIOS_TYPE_SYSTEM_CONFIGURATION_OPTIONS, sizeof (SMBIOS_TABLE_TYPE12), 0 },
     1 // StringCount
   };
   CHAR8 *gSmbiosType12Strings[] = {
     "Not Found",
     NULL
   };

   ...
   LogSmbiosData (
     (EFI_SMBIOS_TABLE_HEADER*)&gSmbiosType12,
     gSmbiosType12Strings
     );

   @param  Template    Fixed SMBIOS structure, required.
   @param  StringArray Array of strings to convert to an SMBIOS string pack.
                       NULL is OK.

 **/
 EFI_STATUS
 LogSmbiosData (
   IN  EFI_SMBIOS_TABLE_HEADER *Template,
   IN  CHAR8                   **StringPack
   )
 {
   EFI_STATUS                Status;
   EFI_SMBIOS_PROTOCOL       *Smbios;
   EFI_SMBIOS_HANDLE         SmbiosHandle;
   EFI_SMBIOS_TABLE_HEADER   *Record;
   UINTN                     Index;
   UINTN                     StringSize;
   UINTN                     Size;
   CHAR8                     *Str;

   //
   // Locate Smbios protocol.
   //
   Status = gBS->LocateProtocol (&gEfiSmbiosProtocolGuid, NULL, (VOID **)&Smbios);
   if (EFI_ERROR (Status)) {
     return Status;
   }

   // Calculate the size of the fixed record and optional string pack
   Size = Template->Length;
   if (StringPack == NULL) {
     // At least a double null is required
     Size += 2;
   } else {
     for (Index = 0; StringPack[Index] != NULL; Index++) {
       StringSize = AsciiStrSize (StringPack[Index]);
       Size += StringSize;
     }
     if (StringPack[0] == NULL) {
       // At least a double null is required
       Size += 1;
     }
     // Don't forget the terminating double null
     Size += 1;
   }

   // Copy over Template
   Record = (EFI_SMBIOS_TABLE_HEADER *)AllocateZeroPool (Size);
   if (Record == NULL) {
     return EFI_OUT_OF_RESOURCES;
   }
   CopyMem (Record, Template, Template->Length);

   // Append string pack
   Str = ((CHAR8 *)Record) + Record->Length;
   for (Index = 0; StringPack[Index] != NULL; Index++) {
     StringSize = AsciiStrSize (StringPack[Index]);
     CopyMem (Str, StringPack[Index], StringSize);
     Str += StringSize;
   }
   *Str = 0;

   SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
   Status = Smbios->Add (
                      Smbios,
                      gImageHandle,
                      &SmbiosHandle,
                      Record
                      );
   ASSERT_EFI_ERROR (Status);

   FreePool (Record);
   return Status;
 }


 VOID
 CpuUpdateSmbios (
   IN UINTN  MaxCpus
   )
 {
   mCpuSmbiosType4.CoreCount        = (UINT8) MaxCpus;
   mCpuSmbiosType4.EnabledCoreCount = (UINT8) MaxCpus;
   mCpuSmbiosType4.ThreadCount      = (UINT8) MaxCpus;

   LogSmbiosData ((EFI_SMBIOS_TABLE_HEADER *)&mCpuSmbiosType4, mCpuSmbiosType4Strings);
 }


 //
 // 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
   )
 {
   return EFI_UNSUPPORTED;
 }

 EFI_STATUS
 EFIAPI
 EmuRegisterInterruptHandler (
   IN EFI_CPU_ARCH_PROTOCOL      *This,
   IN EFI_EXCEPTION_TYPE         InterruptType,
   IN EFI_CPU_INTERRUPT_HANDLER  InterruptHandler
   )
 {
   //
   // Do parameter checking for EFI spec conformance
   //
   if (InterruptType < 0 || InterruptType > 0xff) {
     return EFI_UNSUPPORTED;
   }
   //
   // Do nothing for Emu emulation
   //
   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
   )
 {
   //
   // Check for invalid parameter for Spec conformance
   //
   if (Length == 0) {
     return EFI_INVALID_PARAMETER;
   }

   //
   // Do nothing for Nt32 emulation
   //
   return EFI_UNSUPPORTED;
 }


 /**
   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;
   UINTN         MaxCpu;

   //
   // 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);

   CpuMpServicesInit (&MaxCpu);

   CpuUpdateSmbios (MaxCpu);


   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;
 }
	/*++ @file
	Emu driver to produce CPU Architectural Protocol.

	Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
	Portions copyright (c) 2011 - 2012, 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

	SMBIOS_TABLE_TYPE4 mCpuSmbiosType4 = {
	{ EFI_SMBIOS_TYPE_PROCESSOR_INFORMATION, sizeof (SMBIOS_TABLE_TYPE4), 0},
	1, // Socket String
	ProcessorOther, // ProcessorType; ///< The enumeration value from PROCESSOR_TYPE_DATA.
	ProcessorFamilyOther, // ProcessorFamily; ///< The enumeration value from PROCESSOR_FAMILY_DATA.
	2, // ProcessorManufacture String;
	{ // ProcessorId;
	{ // PROCESSOR_SIGNATURE
	0, // ProcessorSteppingId:4;
	0, // ProcessorModel: 4;
	0, // ProcessorFamily: 4;
	0, // ProcessorType: 2;
	0, // ProcessorReserved1: 2;
	0, // ProcessorXModel: 4;
	0, // ProcessorXFamily: 8;
	0, // ProcessorReserved2: 4;
	},
	{ // PROCESSOR_FEATURE_FLAGS
	0, // ProcessorFpu :1;
	0, // ProcessorVme :1;
	0, // ProcessorDe :1;
	0, // ProcessorPse :1;
	0, // ProcessorTsc :1;
	0, // ProcessorMsr :1;
	0, // ProcessorPae :1;
	0, // ProcessorMce :1;
	0, // ProcessorCx8 :1;
	0, // ProcessorApic :1;
	0, // ProcessorReserved1 :1;
	0, // ProcessorSep :1;
	0, // ProcessorMtrr :1;
	0, // ProcessorPge :1;
	0, // ProcessorMca :1;
	0, // ProcessorCmov :1;
	0, // ProcessorPat :1;
	0, // ProcessorPse36 :1;
	0, // ProcessorPsn :1;
	0, // ProcessorClfsh :1;
	0, // ProcessorReserved2 :1;
	0, // ProcessorDs :1;
	0, // ProcessorAcpi :1;
	0, // ProcessorMmx :1;
	0, // ProcessorFxsr :1;
	0, // ProcessorSse :1;
	0, // ProcessorSse2 :1;
	0, // ProcessorSs :1;
	0, // ProcessorReserved3 :1;
	0, // ProcessorTm :1;
	0, // ProcessorReserved4 :2;
	}
	},
	3, // ProcessorVersion String;
	{ // Voltage;
	1, // ProcessorVoltageCapability5V :1;
	1, // ProcessorVoltageCapability3_3V :1;
	1, // ProcessorVoltageCapability2_9V :1;
	0, // ProcessorVoltageCapabilityReserved :1; ///< Bit 3, must be zero.
	0, // ProcessorVoltageReserved :3; ///< Bits 4-6, must be zero.
	0 // ProcessorVoltageIndicateLegacy :1;
	},
	0, // ExternalClock;
	0, // MaxSpeed;
	0, // CurrentSpeed;
	0x41, // Status;
	ProcessorUpgradeOther, // ProcessorUpgrade; ///< The enumeration value from PROCESSOR_UPGRADE.
	0, // L1CacheHandle;
	0, // L2CacheHandle;
	0, // L3CacheHandle;
	4, // SerialNumber;
	5, // AssetTag;
	6, // PartNumber;
	0, // CoreCount;
	0, // EnabledCoreCount;
	0, // ThreadCount;
	0, // ProcessorCharacteristics;
	0, // ProcessorFamily2;
	};

	CHAR8 *mCpuSmbiosType4Strings[] = {
	"Socket",
	"http://www.tianocore.org/edk2/",
	"Emulated Processor",
	"1.0",
	"1.0",
	"1.0",
	NULL
	};


	/**
	Create SMBIOS record.

	Converts a fixed SMBIOS structure and an array of pointers to strings into
	an SMBIOS record where the strings are cat'ed on the end of the fixed record
	and terminated via a double NULL and add to SMBIOS table.

	SMBIOS_TABLE_TYPE32 gSmbiosType12 = {
	{ EFI_SMBIOS_TYPE_SYSTEM_CONFIGURATION_OPTIONS, sizeof (SMBIOS_TABLE_TYPE12), 0 },
	1 // StringCount
	};
	CHAR8 *gSmbiosType12Strings[] = {
	"Not Found",
	NULL
	};

	...
	LogSmbiosData (
	(EFI_SMBIOS_TABLE_HEADER*)&gSmbiosType12,
	gSmbiosType12Strings
	);

	@param Template Fixed SMBIOS structure, required.
	@param StringArray Array of strings to convert to an SMBIOS string pack.
	NULL is OK.

	**/
	EFI_STATUS
	LogSmbiosData (
	IN EFI_SMBIOS_TABLE_HEADER *Template,
	IN CHAR8 **StringPack
	)
	{
	EFI_STATUS Status;
	EFI_SMBIOS_PROTOCOL *Smbios;
	EFI_SMBIOS_HANDLE SmbiosHandle;
	EFI_SMBIOS_TABLE_HEADER *Record;
	UINTN Index;
	UINTN StringSize;
	UINTN Size;
	CHAR8 *Str;

	//
	// Locate Smbios protocol.
	//
	Status = gBS->LocateProtocol (&gEfiSmbiosProtocolGuid, NULL, (VOID **)&Smbios);
	if (EFI_ERROR (Status)) {
	return Status;
	}

	// Calculate the size of the fixed record and optional string pack
	Size = Template->Length;
	if (StringPack == NULL) {
	// At least a double null is required
	Size += 2;
	} else {
	for (Index = 0; StringPack[Index] != NULL; Index++) {
	StringSize = AsciiStrSize (StringPack[Index]);
	Size += StringSize;
	}
	if (StringPack[0] == NULL) {
	// At least a double null is required
	Size += 1;
	}
	// Don't forget the terminating double null
	Size += 1;
	}

	// Copy over Template
	Record = (EFI_SMBIOS_TABLE_HEADER *)AllocateZeroPool (Size);
	if (Record == NULL) {
	return EFI_OUT_OF_RESOURCES;
	}
	CopyMem (Record, Template, Template->Length);

	// Append string pack
	Str = ((CHAR8 *)Record) + Record->Length;
	for (Index = 0; StringPack[Index] != NULL; Index++) {
	StringSize = AsciiStrSize (StringPack[Index]);
	CopyMem (Str, StringPack[Index], StringSize);
	Str += StringSize;
	}
	*Str = 0;

	SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
	Status = Smbios->Add (
	Smbios,
	gImageHandle,
	&SmbiosHandle,
	Record
	);
	ASSERT_EFI_ERROR (Status);

	FreePool (Record);
	return Status;
	}




	VOID
	CpuUpdateSmbios (
	IN UINTN MaxCpus
	)
	{
	mCpuSmbiosType4.CoreCount = (UINT8) MaxCpus;
	mCpuSmbiosType4.EnabledCoreCount = (UINT8) MaxCpus;
	mCpuSmbiosType4.ThreadCount = (UINT8) MaxCpus;

	LogSmbiosData ((EFI_SMBIOS_TABLE_HEADER *)&mCpuSmbiosType4, mCpuSmbiosType4Strings);
	}


	//
	// 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
	)
	{
	return EFI_UNSUPPORTED;
	}

	EFI_STATUS
	EFIAPI
	EmuRegisterInterruptHandler (
	IN EFI_CPU_ARCH_PROTOCOL *This,
	IN EFI_EXCEPTION_TYPE InterruptType,
	IN EFI_CPU_INTERRUPT_HANDLER InterruptHandler
	)
	{
	//
	// Do parameter checking for EFI spec conformance
	//
	if (InterruptType < 0 \|\| InterruptType > 0xff) {
	return EFI_UNSUPPORTED;
	}
	//
	// Do nothing for Emu emulation
	//
	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
	)
	{
	//
	// Check for invalid parameter for Spec conformance
	//
	if (Length == 0) {
	return EFI_INVALID_PARAMETER;
	}

	//
	// Do nothing for Nt32 emulation
	//
	return EFI_UNSUPPORTED;
	}




	/**
	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;
	UINTN MaxCpu;

	//
	// 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);

	CpuMpServicesInit (&MaxCpu);

	CpuUpdateSmbios (MaxCpu);


	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;
	}