sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Unix version of EFI emulator

Browse Source 
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2182 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
tgingold
2007-01-06 14:59:06 +00:00
parent 8ba7afaf2e
commit c9093a06e7
187 changed files with 54299 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

730
EdkUnixPkg/Dxe/UnixThunk/Cpu/Cpu.c Normal file
View File

@ -0,0 +1,730 @@
/*++
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.c
Abstract:
Unix 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 "CpuDriver.h"
#define EFI_CPU_DATA_MAXIMUM_LENGTH 0x100
EFI_STATUS
EFIAPI
InitializeCpu (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
);
VOID
EFIAPI
UnixIoProtocolNotifyFunction (
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
UnixFlushCpuDataCache (
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
UnixEnableInterrupt (
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
UnixDisableInterrupt (
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
UnixGetInterruptState (
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
UnixInit (
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
UnixRegisterInterruptHandler (
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
UnixGetTimerValue (
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
UnixSetMemoryAttributes (
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;
Status = gBS->AllocatePool (
EfiBootServicesData,
sizeof (CPU_ARCH_PROTOCOL_PRIVATE),
(VOID **)&Private
);
ASSERT_EFI_ERROR (Status);
Private->Signature = CPU_ARCH_PROT_PRIVATE_SIGNATURE;
Private->Cpu.FlushDataCache = UnixFlushCpuDataCache;
Private->Cpu.EnableInterrupt = UnixEnableInterrupt;
Private->Cpu.DisableInterrupt = UnixDisableInterrupt;
Private->Cpu.GetInterruptState = UnixGetInterruptState;
Private->Cpu.Init = UnixInit;
Private->Cpu.RegisterInterruptHandler = UnixRegisterInterruptHandler;
Private->Cpu.GetTimerValue = UnixGetTimerValue;
Private->Cpu.SetMemoryAttributes = UnixSetMemoryAttributes;
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 (
EFI_EVENT_NOTIFY_SIGNAL,
EFI_TPL_CALLBACK,
UnixIoProtocolNotifyFunction,
ImageHandle,
&Event
);
ASSERT (!EFI_ERROR (Status));
Status = gBS->RegisterProtocolNotify (
&gEfiUnixIoProtocolGuid,
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 (
UINT16 *String
)
/*++
Routine Description:
Convert a unicode string to a UINTN
Arguments:
String - Unicode string.
Returns:
UINTN of the number represented by String.
--*/
{
UINTN Number;
UINT16 *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
UnixIoProtocolNotifyFunction (
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_UNIX_IO_PROTOCOL *UnixIo;
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,
&gEfiUnixIoProtocolGuid,
NULL,
&HandleCount,
&HandleBuffer
);
if (EFI_ERROR (Status)) {
return ;
}
//
// Locate HII protocol
//
Status = gBS->LocateProtocol (&gEfiHiiProtocolGuid, NULL, (VOID **)&Hii);
if (EFI_ERROR (Status)) {
return ;
}
//
// Locate DataHub protocol.
//
Status = gBS->LocateProtocol (&gEfiDataHubProtocolGuid, NULL, (VOID **)&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],
&gEfiUnixIoProtocolGuid,
(VOID **)&UnixIo,
Context,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
continue;
}
if ((UnixIo->UnixThunk->Signature == EFI_UNIX_THUNK_PROTOCOL_SIGNATURE) &&
CompareGuid (UnixIo->TypeGuid, &gEfiUnixCPUModelGuid)
) {
//
// 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, STRING_ARRAY_NAME);
Status = Hii->NewPack (Hii, PackageList, &StringHandle);
ASSERT (!EFI_ERROR (Status));
gBS->FreePool (PackageList);
//
// Store processor version data record to data hub
//
Status = Hii->NewString (Hii, NULL, StringHandle, &Token, UnixIo->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 ((UnixIo->UnixThunk->Signature == EFI_UNIX_THUNK_PROTOCOL_SIGNATURE) &&
CompareGuid (UnixIo->TypeGuid, &gEfiUnixCPUSpeedGuid)
) {
//
// 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 (UnixIo->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
);
gBS->FreePool (RecordBuffer.Raw);
}
gBS->CloseProtocol (
HandleBuffer[HandleIndex],
&gEfiUnixIoProtocolGuid,
Context,
NULL
);
}
}

28
EdkUnixPkg/Dxe/UnixThunk/Cpu/Cpu.dxs Normal file
View File

@ -0,0 +1,28 @@
/*++
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 <AutoGen.h>
#include <DxeDepex.h>
DEPENDENCY_START
EFI_DATA_HUB_PROTOCOL_GUID AND
EFI_HII_PROTOCOL_GUID
DEPENDENCY_END

108
EdkUnixPkg/Dxe/UnixThunk/Cpu/Cpu.msa Normal file
View File

@ -0,0 +1,108 @@
<?xml version="1.0" encoding="UTF-8"?>
<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0">
<MsaHeader>
<ModuleName>Cpu</ModuleName>
<ModuleType>DXE_DRIVER</ModuleType>
<GuidValue>f3794b60-8985-11db-8e53-0040d02b1835</GuidValue>
<Version>1.0</Version>
<Abstract>Component description file for Cpu module.</Abstract>
<Description>This CPU module abstracts the interrupt subsystem of a platform and the CPU-specific setjump-long pair.</Description>
<Copyright>Copyright (c) 2006, Intel Corporation</Copyright>
<License>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.</License>
<Specification>FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052</Specification>
</MsaHeader>
<ModuleDefinitions>
<SupportedArchitectures>IA32 X64 IPF EBC</SupportedArchitectures>
<BinaryModule>false</BinaryModule>
<OutputFileBasename>Cpu</OutputFileBasename>
</ModuleDefinitions>
<LibraryClassDefinitions>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>BaseLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>DebugLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>HiiLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiDriverEntryPoint</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>BaseMemoryLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>MemoryAllocationLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiBootServicesTableLib</Keyword>
</LibraryClass>
</LibraryClassDefinitions>
<SourceFiles>
<Filename>Strings.uni</Filename>
<Filename>CpuDriver.h</Filename>
<Filename>Cpu.c</Filename>
<Filename>CpuIo.c</Filename>
<Filename>Cpu.dxs</Filename>
</SourceFiles>
<PackageDependencies>
<Package PackageGuid="5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec"/>
<Package PackageGuid="68169ab0-d41b-4009-9060-292c253ac43d"/>
<Package PackageGuid="f2805c44-8985-11db-9e98-0040d02b1835"/>
</PackageDependencies>
<Protocols>
<Protocol Usage="ALWAYS_PRODUCED">
<ProtocolCName>gEfiCpuArchProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="ALWAYS_PRODUCED">
<ProtocolCName>gEfiCpuIoProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="SOMETIMES_CONSUMED">
<ProtocolCName>gEfiHiiProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="SOMETIMES_CONSUMED">
<ProtocolCName>gEfiDataHubProtocolGuid</ProtocolCName>
</Protocol>
<ProtocolNotify Usage="SOMETIMES_CONSUMED">
<ProtocolNotifyCName>gEfiUnixIoProtocolGuid</ProtocolNotifyCName>
</ProtocolNotify>
</Protocols>
<DataHubs>
<DataHubRecord Usage="SOMETIMES_PRODUCED">
<DataHubCName>ProcessorVersion</DataHubCName>
</DataHubRecord>
<DataHubRecord Usage="SOMETIMES_PRODUCED">
<DataHubCName>ProcessorCoreFrequency</DataHubCName>
</DataHubRecord>
</DataHubs>
<Guids>
<GuidCNames Usage="SOMETIMES_CONSUMED">
<GuidCName>gEfiProcessorProducerGuid</GuidCName>
</GuidCNames>
<GuidCNames Usage="SOMETIMES_CONSUMED">
<GuidCName>gEfiProcessorSubClassGuid</GuidCName>
</GuidCNames>
<GuidCNames Usage="SOMETIMES_CONSUMED">
<GuidCName>gEfiUnixCPUModelGuid</GuidCName>
</GuidCNames>
<GuidCNames Usage="SOMETIMES_CONSUMED">
<GuidCName>gEfiUnixCPUSpeedGuid</GuidCName>
</GuidCNames>
</Guids>
<Externs>
<Specification>EFI_SPECIFICATION_VERSION 0x00020000</Specification>
<Specification>EDK_RELEASE_VERSION 0x00020000</Specification>
<Extern>
<ModuleEntryPoint>InitializeCpu</ModuleEntryPoint>
</Extern>
</Externs>
</ModuleSurfaceArea>

96
EdkUnixPkg/Dxe/UnixThunk/Cpu/CpuDriver.h Normal file
View File

@ -0,0 +1,96 @@
/*++
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_
extern UINT8 STRING_ARRAY_NAME[];
//
// 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
//
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

335
EdkUnixPkg/Dxe/UnixThunk/Cpu/CpuIo.c Normal file
View File

@ -0,0 +1,335 @@
/*++
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 <CpuDriver.h>
#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;
}

BIN
EdkUnixPkg/Dxe/UnixThunk/Cpu/Strings.uni Normal file
View File

Binary file not shown.