From: qwang12 Date: Fri, 29 Jun 2007 03:02:40 +0000 (+0000) Subject: add in CpuRuntimeDxe X-Git-Tag: edk2-stable201903~23084 X-Git-Url: https://git.proxmox.com/?p=mirror_edk2.git;a=commitdiff_plain;h=770bcbb646db89f2dd88262891017c6372fb8baa add in CpuRuntimeDxe git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2871 6f19259b-4bc3-4df7-8a09-765794883524 --- diff --git a/Nt32Pkg/CpuRuntimeDxe/CommonHeader.h b/Nt32Pkg/CpuRuntimeDxe/CommonHeader.h new file mode 100644 index 0000000000..f63563c8fb --- /dev/null +++ b/Nt32Pkg/CpuRuntimeDxe/CommonHeader.h @@ -0,0 +1,44 @@ +/**@file + Common header file shared by all source files. + + This file includes package header files, library classes and protocol, PPI & GUID definitions. + + Copyright (c) 2006 - 2007, Intel Corporation + 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 __COMMON_HEADER_H_ +#define __COMMON_HEADER_H_ + + +// +// The package level header files this module uses +// +#include +#include +// +// The protocols, PPI and GUID defintions for this module +// +#include +#include +#include +#include +#include +#include +#include +// +// The Library classes this module consumes +// +#include +#include +#include +#include +#include +#include + +#endif diff --git a/Nt32Pkg/CpuRuntimeDxe/Cpu.c b/Nt32Pkg/CpuRuntimeDxe/Cpu.c new file mode 100644 index 0000000000..499ec2da8c --- /dev/null +++ b/Nt32Pkg/CpuRuntimeDxe/Cpu.c @@ -0,0 +1,731 @@ +/*++ + +Copyright (c) 2006 - 2007, Intel Corporation +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. + +Module Name: + + Cpu.c + +Abstract: + + NT Emulation Architectural Protocol Driver as defined in Tiano. + This CPU module abstracts the interrupt subsystem of a platform and + the CPU-specific setjump/long pair. Other services are not implemented + in this driver. + +--*/ + +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +#include "CpuDriver.h" + +#define EFI_CPU_DATA_MAXIMUM_LENGTH 0x100 + +EFI_STATUS +EFIAPI +InitializeCpu ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ); + +VOID +EFIAPI +WinNtIoProtocolNotifyFunction ( + IN EFI_EVENT Event, + IN VOID *Context + ); + +typedef union { + EFI_CPU_DATA_RECORD *DataRecord; + UINT8 *Raw; +} EFI_CPU_DATA_RECORD_BUFFER; + +EFI_SUBCLASS_TYPE1_HEADER mCpuDataRecordHeader = { + EFI_PROCESSOR_SUBCLASS_VERSION, // Version + sizeof (EFI_SUBCLASS_TYPE1_HEADER), // Header Size + 0, // Instance, Initialize later + EFI_SUBCLASS_INSTANCE_NON_APPLICABLE, // SubInstance + 0 // RecordType, Initialize later +}; + +// +// Service routines for the driver +// +STATIC +EFI_STATUS +EFIAPI +WinNtFlushCpuDataCache ( + IN EFI_CPU_ARCH_PROTOCOL *This, + IN EFI_PHYSICAL_ADDRESS Start, + IN UINT64 Length, + IN EFI_CPU_FLUSH_TYPE FlushType + ) +/*++ + +Routine Description: + + This routine would provide support for flushing the CPU data cache. + In the case of NT emulation environment, this flushing is not necessary and + is thus not implemented. + +Arguments: + + Pointer to CPU Architectural Protocol interface + Start adddress in memory to flush + Length of memory to flush + Flush type + +Returns: + + Status + EFI_SUCCESS + +--*/ +// TODO: This - add argument and description to function comment +// TODO: FlushType - add argument and description to function comment +// TODO: EFI_UNSUPPORTED - add return value to function comment +{ + if (FlushType == EfiCpuFlushTypeWriteBackInvalidate) { + // + // Only WB flush is supported. We actually need do nothing on NT emulator + // environment. Classify this to follow EFI spec + // + return EFI_SUCCESS; + } + // + // Other flush types are not supported by NT emulator + // + return EFI_UNSUPPORTED; +} + +STATIC +EFI_STATUS +EFIAPI +WinNtEnableInterrupt ( + IN EFI_CPU_ARCH_PROTOCOL *This + ) +/*++ + +Routine Description: + + This routine provides support for emulation of the interrupt enable of the + the system. For our purposes, CPU enable is just a BOOLEAN that the Timer + Architectural Protocol observes in order to defer behaviour while in its + emulated interrupt, or timer tick. + +Arguments: + + Pointer to CPU Architectural Protocol interface + +Returns: + + Status + EFI_SUCCESS + +--*/ +// TODO: This - add argument and description to function comment +{ + CPU_ARCH_PROTOCOL_PRIVATE *Private; + + Private = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This); + Private->InterruptState = TRUE; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +EFIAPI +WinNtDisableInterrupt ( + IN EFI_CPU_ARCH_PROTOCOL *This + ) +/*++ + +Routine Description: + + This routine provides support for emulation of the interrupt disable of the + the system. For our purposes, CPU enable is just a BOOLEAN that the Timer + Architectural Protocol observes in order to defer behaviour while in its + emulated interrupt, or timer tick. + +Arguments: + + Pointer to CPU Architectural Protocol interface + +Returns: + + Status + EFI_SUCCESS + +--*/ +// TODO: This - add argument and description to function comment +{ + CPU_ARCH_PROTOCOL_PRIVATE *Private; + + Private = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This); + Private->InterruptState = FALSE; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +EFIAPI +WinNtGetInterruptState ( + IN EFI_CPU_ARCH_PROTOCOL *This, + OUT BOOLEAN *State + ) +/*++ + +Routine Description: + + This routine provides support for emulation of the interrupt disable of the + the system. For our purposes, CPU enable is just a BOOLEAN that the Timer + Architectural Protocol observes in order to defer behaviour while in its + emulated interrupt, or timer tick. + +Arguments: + + Pointer to CPU Architectural Protocol interface + +Returns: + + Status + EFI_SUCCESS + +--*/ +// TODO: This - add argument and description to function comment +// TODO: State - add argument and description to function comment +// TODO: EFI_INVALID_PARAMETER - add return value to function comment +{ + 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; +} + +STATIC +EFI_STATUS +EFIAPI +WinNtInit ( + IN EFI_CPU_ARCH_PROTOCOL *This, + IN EFI_CPU_INIT_TYPE InitType + ) +/*++ + +Routine Description: + + This routine would support generation of a CPU INIT. At + present, this code does not provide emulation. + +Arguments: + + Pointer to CPU Architectural Protocol interface + INIT Type + +Returns: + + Status + EFI_UNSUPPORTED - not yet implemented + +--*/ +// TODO: This - add argument and description to function comment +// TODO: InitType - add argument and description to function comment +{ + CPU_ARCH_PROTOCOL_PRIVATE *Private; + + Private = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This); + return EFI_UNSUPPORTED; +} + +STATIC +EFI_STATUS +EFIAPI +WinNtRegisterInterruptHandler ( + IN EFI_CPU_ARCH_PROTOCOL *This, + IN EFI_EXCEPTION_TYPE InterruptType, + IN EFI_CPU_INTERRUPT_HANDLER InterruptHandler + ) +/*++ + +Routine Description: + + This routine would support registration of an interrupt handler. At + present, this code does not provide emulation. + +Arguments: + + Pointer to CPU Architectural Protocol interface + Pointer to interrupt handlers + Interrupt type + +Returns: + + Status + EFI_UNSUPPORTED - not yet implemented + +--*/ +// TODO: This - add argument and description to function comment +// TODO: InterruptType - add argument and description to function comment +// TODO: InterruptHandler - add argument and description to function comment +{ + CPU_ARCH_PROTOCOL_PRIVATE *Private; + + // + // Do parameter checking for EFI spec conformance + // + if (InterruptType < 0 || InterruptType > 0xff) { + return EFI_UNSUPPORTED; + } + // + // Do nothing for Nt32 emulation + // + Private = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This); + return EFI_UNSUPPORTED; +} + +STATIC +EFI_STATUS +EFIAPI +WinNtGetTimerValue ( + IN EFI_CPU_ARCH_PROTOCOL *This, + IN UINT32 TimerIndex, + OUT UINT64 *TimerValue, + OUT UINT64 *TimerPeriod OPTIONAL + ) +/*++ + +Routine Description: + + This routine would support querying of an on-CPU timer. At present, + this code does not provide timer emulation. + +Arguments: + + This - Pointer to CPU Architectural Protocol interface + TimerIndex - Index of given CPU timer + TimerValue - Output of the timer + TimerPeriod - Output of the timer period + +Returns: + + EFI_UNSUPPORTED - not yet implemented + EFI_INVALID_PARAMETER - TimeValue is NULL + +--*/ +{ + if (TimerValue == NULL) { + return EFI_INVALID_PARAMETER; + } + + // + // No timer supported + // + return EFI_UNSUPPORTED; +} + +STATIC +EFI_STATUS +EFIAPI +WinNtSetMemoryAttributes ( + IN EFI_CPU_ARCH_PROTOCOL *This, + IN EFI_PHYSICAL_ADDRESS BaseAddress, + IN UINT64 Length, + IN UINT64 Attributes + ) +/*++ + +Routine Description: + + This routine would support querying of an on-CPU timer. At present, + this code does not provide timer emulation. + +Arguments: + + Pointer to CPU Architectural Protocol interface + Start address of memory region + The size in bytes of the memory region + The bit mask of attributes to set for the memory region + +Returns: + + Status + EFI_UNSUPPORTED - not yet implemented + +--*/ +// TODO: This - add argument and description to function comment +// TODO: BaseAddress - add argument and description to function comment +// TODO: Length - add argument and description to function comment +// TODO: Attributes - add argument and description to function comment +// TODO: EFI_INVALID_PARAMETER - add return value to function comment +{ + 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; +} + + +EFI_STATUS +EFIAPI +InitializeCpu ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +/*++ + +Routine Description: + + Initialize the state information for the CPU Architectural Protocol + +Arguments: + + ImageHandle of the loaded driver + Pointer to the System Table + +Returns: + + Status + + EFI_SUCCESS - protocol instance can be published + EFI_OUT_OF_RESOURCES - cannot allocate protocol data structure + EFI_DEVICE_ERROR - cannot create the thread + +--*/ +// TODO: SystemTable - add argument and description to function comment +{ + EFI_STATUS Status; + EFI_EVENT Event; + CPU_ARCH_PROTOCOL_PRIVATE *Private; + VOID *Registration; + + Private = AllocatePool (sizeof (CPU_ARCH_PROTOCOL_PRIVATE)); + ASSERT (Private != NULL); + + Private->Signature = CPU_ARCH_PROT_PRIVATE_SIGNATURE; + Private->Cpu.FlushDataCache = WinNtFlushCpuDataCache; + Private->Cpu.EnableInterrupt = WinNtEnableInterrupt; + Private->Cpu.DisableInterrupt = WinNtDisableInterrupt; + Private->Cpu.GetInterruptState = WinNtGetInterruptState; + Private->Cpu.Init = WinNtInit; + Private->Cpu.RegisterInterruptHandler = WinNtRegisterInterruptHandler; + Private->Cpu.GetTimerValue = WinNtGetTimerValue; + Private->Cpu.SetMemoryAttributes = WinNtSetMemoryAttributes; + + Private->Cpu.NumberOfTimers = 0; + Private->Cpu.DmaBufferAlignment = 4; + + Private->InterruptState = TRUE; + + Private->CpuIo.Mem.Read = CpuMemoryServiceRead; + Private->CpuIo.Mem.Write = CpuMemoryServiceWrite; + Private->CpuIo.Io.Read = CpuIoServiceRead; + Private->CpuIo.Io.Write = CpuIoServiceWrite; + + + Private->Handle = NULL; + Status = gBS->InstallMultipleProtocolInterfaces ( + &Private->Handle, + &gEfiCpuArchProtocolGuid, &Private->Cpu, + &gEfiCpuIoProtocolGuid, &Private->CpuIo, + NULL + ); + ASSERT_EFI_ERROR (Status); + + // + // Install notify function to store processor data to HII database and data hub. + // + Status = gBS->CreateEvent ( + EVT_NOTIFY_SIGNAL, + TPL_CALLBACK, + WinNtIoProtocolNotifyFunction, + ImageHandle, + &Event + ); + ASSERT (!EFI_ERROR (Status)); + + Status = gBS->RegisterProtocolNotify ( + &gEfiWinNtIoProtocolGuid, + Event, + &Registration + ); + ASSERT (!EFI_ERROR (Status)); + + // + // Should be at EFI_D_INFO, but lets us now things are running + // + DEBUG ((EFI_D_ERROR, "CPU Architectural Protocol Loaded\n")); + + + + return Status; +} + +UINTN +Atoi ( + CHAR16 *String + ) +/*++ + +Routine Description: + Convert a unicode string to a UINTN + +Arguments: + String - Unicode string. + +Returns: + UINTN of the number represented by String. + +--*/ +{ + UINTN Number; + CHAR16 *Str; + + // + // skip preceeding white space + // + Str = String; + while ((*Str) && (*Str == ' ' || *Str == '"')) { + Str++; + } + // + // Convert ot a Number + // + Number = 0; + while (*Str != '\0') { + if ((*Str >= '0') && (*Str <= '9')) { + Number = (Number * 10) +*Str - '0'; + } else { + break; + } + + Str++; + } + + return Number; +} + +VOID +EFIAPI +WinNtIoProtocolNotifyFunction ( + IN EFI_EVENT Event, + IN VOID *Context + ) +/*++ + +Routine Description: + This function will log processor version and frequency data to data hub. + +Arguments: + Event - Event whose notification function is being invoked. + Context - Pointer to the notification function's context. + +Returns: + None. + +--*/ +{ + EFI_STATUS Status; + EFI_CPU_DATA_RECORD_BUFFER RecordBuffer; + EFI_DATA_RECORD_HEADER *Record; + EFI_SUBCLASS_TYPE1_HEADER *DataHeader; + UINT32 HeaderSize; + UINT32 TotalSize; + UINTN HandleCount; + UINTN HandleIndex; + UINT64 MonotonicCount; + BOOLEAN RecordFound; + EFI_HANDLE *HandleBuffer; + EFI_WIN_NT_IO_PROTOCOL *WinNtIo; + EFI_DATA_HUB_PROTOCOL *DataHub; + EFI_HII_PROTOCOL *Hii; + EFI_HII_HANDLE StringHandle; + EFI_HII_PACKAGES *PackageList; + STRING_REF Token; + + DataHub = NULL; + Token = 0; + MonotonicCount = 0; + RecordFound = FALSE; + + // + // Retrieve the list of all handles from the handle database + // + Status = gBS->LocateHandleBuffer ( + AllHandles, + &gEfiWinNtIoProtocolGuid, + NULL, + &HandleCount, + &HandleBuffer + ); + if (EFI_ERROR (Status)) { + return ; + } + // + // Locate HII protocol + // + Status = gBS->LocateProtocol (&gEfiHiiProtocolGuid, NULL, &Hii); + if (EFI_ERROR (Status)) { + return ; + } + // + // Locate DataHub protocol. + // + Status = gBS->LocateProtocol (&gEfiDataHubProtocolGuid, NULL, &DataHub); + if (EFI_ERROR (Status)) { + return ; + } + // + // Initialize data record header + // + mCpuDataRecordHeader.Instance = 1; + HeaderSize = sizeof (EFI_SUBCLASS_TYPE1_HEADER); + + RecordBuffer.Raw = AllocatePool (HeaderSize + EFI_CPU_DATA_MAXIMUM_LENGTH); + if (RecordBuffer.Raw == NULL) { + return ; + } + + CopyMem (RecordBuffer.Raw, &mCpuDataRecordHeader, HeaderSize); + + // + // Search the Handle array to find the CPU model and speed information + // + for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) { + Status = gBS->OpenProtocol ( + HandleBuffer[HandleIndex], + &gEfiWinNtIoProtocolGuid, + &WinNtIo, + Context, + NULL, + EFI_OPEN_PROTOCOL_GET_PROTOCOL + ); + if (EFI_ERROR (Status)) { + continue; + } + + if ((WinNtIo->WinNtThunk->Signature == EFI_WIN_NT_THUNK_PROTOCOL_SIGNATURE) && + CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtCPUModelGuid) + ) { + // + // Check if this record has been stored in data hub + // + do { + Status = DataHub->GetNextRecord (DataHub, &MonotonicCount, NULL, &Record); + if (Record->DataRecordClass == EFI_DATA_RECORD_CLASS_DATA) { + DataHeader = (EFI_SUBCLASS_TYPE1_HEADER *) (Record + 1); + if (CompareGuid (&Record->DataRecordGuid, &gEfiProcessorSubClassGuid) && + (DataHeader->RecordType == ProcessorVersionRecordType) + ) { + RecordFound = TRUE; + } + } + } while (MonotonicCount != 0); + + if (RecordFound) { + RecordFound = FALSE; + continue; + } + // + // Initialize strings to HII database + // + PackageList = PreparePackages (1, &gEfiProcessorProducerGuid, CpuStrings); + + Status = Hii->NewPack (Hii, PackageList, &StringHandle); + ASSERT (!EFI_ERROR (Status)); + + FreePool (PackageList); + + // + // Store processor version data record to data hub + // + Status = Hii->NewString (Hii, NULL, StringHandle, &Token, WinNtIo->EnvString); + ASSERT (!EFI_ERROR (Status)); + + RecordBuffer.DataRecord->DataRecordHeader.RecordType = ProcessorVersionRecordType; + RecordBuffer.DataRecord->VariableRecord.ProcessorVersion = Token; + TotalSize = HeaderSize + sizeof (EFI_PROCESSOR_VERSION_DATA); + + Status = DataHub->LogData ( + DataHub, + &gEfiProcessorSubClassGuid, + &gEfiProcessorProducerGuid, + EFI_DATA_RECORD_CLASS_DATA, + RecordBuffer.Raw, + TotalSize + ); + } + + if ((WinNtIo->WinNtThunk->Signature == EFI_WIN_NT_THUNK_PROTOCOL_SIGNATURE) && + CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtCPUSpeedGuid) + ) { + // + // Check if this record has been stored in data hub + // + do { + Status = DataHub->GetNextRecord (DataHub, &MonotonicCount, NULL, &Record); + if (Record->DataRecordClass == EFI_DATA_RECORD_CLASS_DATA) { + DataHeader = (EFI_SUBCLASS_TYPE1_HEADER *) (Record + 1); + if (CompareGuid (&Record->DataRecordGuid, &gEfiProcessorSubClassGuid) && + (DataHeader->RecordType == ProcessorCoreFrequencyRecordType) + ) { + RecordFound = TRUE; + } + } + } while (MonotonicCount != 0); + + if (RecordFound) { + RecordFound = FALSE; + continue; + } + // + // Store CPU frequency data record to data hub + // + RecordBuffer.DataRecord->DataRecordHeader.RecordType = ProcessorCoreFrequencyRecordType; + RecordBuffer.DataRecord->VariableRecord.ProcessorCoreFrequency.Value = (UINT16) Atoi (WinNtIo->EnvString); + RecordBuffer.DataRecord->VariableRecord.ProcessorCoreFrequency.Exponent = 6; + TotalSize = HeaderSize + sizeof (EFI_PROCESSOR_CORE_FREQUENCY_DATA); + + Status = DataHub->LogData ( + DataHub, + &gEfiProcessorSubClassGuid, + &gEfiProcessorProducerGuid, + EFI_DATA_RECORD_CLASS_DATA, + RecordBuffer.Raw, + TotalSize + ); + + FreePool (RecordBuffer.Raw); + } + + gBS->CloseProtocol ( + HandleBuffer[HandleIndex], + &gEfiWinNtIoProtocolGuid, + Context, + NULL + ); + } +} diff --git a/Nt32Pkg/CpuRuntimeDxe/Cpu.dxs b/Nt32Pkg/CpuRuntimeDxe/Cpu.dxs new file mode 100644 index 0000000000..d4f2df0fc0 --- /dev/null +++ b/Nt32Pkg/CpuRuntimeDxe/Cpu.dxs @@ -0,0 +1,31 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +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. + +Module Name: + + Cpu.dxs + +Abstract: + + Dependency expression source file. + +--*/ +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +#include + +DEPENDENCY_START + EFI_DATA_HUB_PROTOCOL_GUID AND + EFI_HII_PROTOCOL_GUID +DEPENDENCY_END diff --git a/Nt32Pkg/CpuRuntimeDxe/Cpu.inf b/Nt32Pkg/CpuRuntimeDxe/Cpu.inf new file mode 100644 index 0000000000..d965523b7a --- /dev/null +++ b/Nt32Pkg/CpuRuntimeDxe/Cpu.inf @@ -0,0 +1,109 @@ +#/** @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 - 2007, Intel Corporation +# +# 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. +# +# +#**/ + +################################################################################ +# +# Defines Section - statements that will be processed to create a Makefile. +# +################################################################################ +[Defines] + INF_VERSION = 0x00010005 + BASE_NAME = Cpu + FILE_GUID = ee993080-5197-4d4e-b63c-f1f7413e33ce + MODULE_TYPE = DXE_DRIVER + VERSION_STRING = 1.0 + EDK_RELEASE_VERSION = 0x00020000 + EFI_SPECIFICATION_VERSION = 0x00020000 + + ENTRY_POINT = InitializeCpu + +# +# The following information is for reference only and not required by the build tools. +# +# VALID_ARCHITECTURES = IA32 +# + +################################################################################ +# +# Sources Section - list of files that are required for the build to succeed. +# +################################################################################ + +[Sources.common] + Cpu.dxs + CpuIo.c + Cpu.c + CpuDriver.h + Strings.uni + CommonHeader.h + + +################################################################################ +# +# Package Dependency Section - list of Package files that are required for +# this module. +# +################################################################################ + +[Packages] + MdePkg/MdePkg.dec + IntelFrameworkPkg/IntelFrameworkPkg.dec + + +################################################################################ +# +# Library Class Section - list of Library Classes that are required for +# this module. +# +################################################################################ + +[LibraryClasses] + UefiBootServicesTableLib + MemoryAllocationLib + BaseMemoryLib + UefiDriverEntryPoint + FrameworkHiiLib + DebugLib + + +################################################################################ +# +# Guid C Name Section - list of Guids that this module uses or produces. +# +################################################################################ + +[Guids] + gEfiWinNtCPUSpeedGuid # SOMETIMES_CONSUMED + gEfiWinNtCPUModelGuid # SOMETIMES_CONSUMED + gEfiProcessorSubClassGuid # SOMETIMES_CONSUMED + gEfiProcessorProducerGuid # SOMETIMES_CONSUMED + + +################################################################################ +# +# Protocol C Name Section - list of Protocol and Protocol Notify C Names +# that this module uses or produces. +# +################################################################################ + +[Protocols] + gEfiWinNtIoProtocolGuid # PROTOCOL_NOTIFY SOMETIMES_CONSUMED + gEfiDataHubProtocolGuid # PROTOCOL SOMETIMES_CONSUMED + gEfiHiiProtocolGuid # PROTOCOL SOMETIMES_CONSUMED + gEfiWinNtIoProtocolGuid # PROTOCOL ALWAYS_CONSUMED + gEfiCpuIoProtocolGuid # PROTOCOL ALWAYS_PRODUCED + gEfiCpuArchProtocolGuid # PROTOCOL ALWAYS_PRODUCED + diff --git a/Nt32Pkg/CpuRuntimeDxe/Cpu.msa b/Nt32Pkg/CpuRuntimeDxe/Cpu.msa new file mode 100644 index 0000000000..f0f22f9540 --- /dev/null +++ b/Nt32Pkg/CpuRuntimeDxe/Cpu.msa @@ -0,0 +1,104 @@ + + + + Cpu + DXE_DRIVER + ee993080-5197-4d4e-b63c-f1f7413e33ce + 1.0 + 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 - 2007, Intel Corporation + 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. + FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052 + + + IA32 + false + Cpu + + + + DebugLib + + + HiiLib + + + UefiDriverEntryPoint + + + BaseMemoryLib + + + MemoryAllocationLib + + + UefiBootServicesTableLib + + + + Strings.uni + CpuDriver.h + Cpu.c + CpuIo.c + Cpu.dxs + + + + + + + + gEfiCpuArchProtocolGuid + + + gEfiCpuIoProtocolGuid + + + gEfiWinNtIoProtocolGuid + + + gEfiHiiProtocolGuid + + + gEfiDataHubProtocolGuid + + + gEfiWinNtIoProtocolGuid + + + + + ProcessorVersion + + + ProcessorCoreFrequency + + + + + gEfiProcessorProducerGuid + + + gEfiProcessorSubClassGuid + + + gEfiWinNtCPUModelGuid + + + gEfiWinNtCPUSpeedGuid + + + + EFI_SPECIFICATION_VERSION 0x00020000 + EDK_RELEASE_VERSION 0x00020000 + + InitializeCpu + + + \ No newline at end of file diff --git a/Nt32Pkg/CpuRuntimeDxe/CpuDriver.h b/Nt32Pkg/CpuRuntimeDxe/CpuDriver.h new file mode 100644 index 0000000000..781d8c65df --- /dev/null +++ b/Nt32Pkg/CpuRuntimeDxe/CpuDriver.h @@ -0,0 +1,102 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +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. + +Module Name: + + CpuDriver.h + +Abstract: + + NT Emulation Architectural Protocol Driver as defined in Tiano. + +--*/ + +#ifndef _CPU_ARCHITECTURAL_PROTOCOL_DRIVER_H_ +#define _CPU_ARCHITECTURAL_PROTOCOL_DRIVER_H_ + + + +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +extern UINT8 CpuStrings[]; + +// +// Internal Data Structures +// +#define CPU_ARCH_PROT_PRIVATE_SIGNATURE EFI_SIGNATURE_32 ('c', 'a', 'p', 'd') + +typedef struct { + UINTN Signature; + EFI_HANDLE Handle; + + EFI_CPU_ARCH_PROTOCOL Cpu; + EFI_CPU_IO_PROTOCOL CpuIo; + + // + // Local Data for CPU interface goes here + // + CRITICAL_SECTION NtCriticalSection; + 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 \ + ) + +EFI_STATUS +EFIAPI +CpuMemoryServiceRead ( + IN EFI_CPU_IO_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_IO_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_IO_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_IO_PROTOCOL *This, + IN EFI_CPU_IO_PROTOCOL_WIDTH Width, + IN UINT64 UserAddress, + IN UINTN Count, + IN OUT VOID *UserBuffer + ); + + +#endif diff --git a/Nt32Pkg/CpuRuntimeDxe/CpuIo.c b/Nt32Pkg/CpuRuntimeDxe/CpuIo.c new file mode 100644 index 0000000000..a3b7c59e91 --- /dev/null +++ b/Nt32Pkg/CpuRuntimeDxe/CpuIo.c @@ -0,0 +1,340 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +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. + +Module Name: + + CpuIo.c + +Abstract: + + 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. + +--*/ + +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +#include + +#define IA32_MAX_IO_ADDRESS 0xFFFF +#define IA32_MAX_MEM_ADDRESS 0xFFFFFFFF + +EFI_CPU_IO_PROTOCOL mCpuIoProtocol; + +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_IO_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. + +--*/ +// TODO: This - add argument and description to function comment +{ + 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_IO_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. + +--*/ +// TODO: This - add argument and description to function comment +{ + 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_IO_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. +--*/ +// TODO: This - add argument and description to function comment +// TODO: UserAddress - add argument and description to function comment +// TODO: UserBuffer - add argument and description to function comment +{ + 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_IO_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. + +--*/ +// TODO: This - add argument and description to function comment +// TODO: UserAddress - add argument and description to function comment +// TODO: UserBuffer - add argument and description to function comment +{ + 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 +CpuIoCheckAddressRange ( + IN EFI_CPU_IO_PROTOCOL_WIDTH Width, + IN UINT64 Address, + IN UINTN Count, + IN VOID *Buffer, + IN UINT64 Limit + ) +/*++ + +Routine Description: + + TODO: Add function 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 + +--*/ +{ + 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; +} + + diff --git a/Nt32Pkg/CpuRuntimeDxe/Strings.uni b/Nt32Pkg/CpuRuntimeDxe/Strings.uni new file mode 100644 index 0000000000..fd70fb9068 Binary files /dev/null and b/Nt32Pkg/CpuRuntimeDxe/Strings.uni differ