tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

removed gEfiWinNtCPUSpeedGuid, gEfiWinNtCPUModelGuid, and gEfiWinNtMemoryGuid. Replaced them with the PCD values they represent. There was no need to use the driver model, when you could get PCD value directly. Also removed local copies of Atoi() in several modules. Fixed bug in reporting of memory size. 

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@3458 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
AJFISH 2007-07-26 21:33:37 +00:00
parent 0963b13df5
commit b397fbbbf9
24 changed files with 320 additions and 1096 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

466
Nt32Pkg/CpuRuntimeDxe/Cpu.c
View File

@ -25,21 +25,35 @@ Abstract:
#include "CpuDriver.h"
CPU_ARCH_PROTOCOL_PRIVATE mCpuTemplate = {
CPU_ARCH_PROT_PRIVATE_SIGNATURE,
NULL,
{
WinNtFlushCpuDataCache,
WinNtEnableInterrupt,
WinNtDisableInterrupt,
WinNtGetInterruptState,
WinNtInit,
WinNtRegisterInterruptHandler,
WinNtGetTimerValue,
WinNtSetMemoryAttributes,
0,
4
},
{
CpuMemoryServiceRead,
CpuMemoryServiceWrite,
CpuIoServiceRead,
CpuIoServiceWrite
},
0,
TRUE
};
#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;
@ -57,7 +71,6 @@ EFI_SUBCLASS_TYPE1_HEADER mCpuDataRecordHeader = {
//
// Service routines for the driver
//
STATIC
EFI_STATUS
EFIAPI
WinNtFlushCpuDataCache (
@ -104,7 +117,7 @@ Returns:
return EFI_UNSUPPORTED;
}
STATIC
EFI_STATUS
EFIAPI
WinNtEnableInterrupt (
@ -138,7 +151,7 @@ Returns:
return EFI_SUCCESS;
}
STATIC
EFI_STATUS
EFIAPI
WinNtDisableInterrupt (
@ -172,7 +185,7 @@ Returns:
return EFI_SUCCESS;
}
STATIC
EFI_STATUS
EFIAPI
WinNtGetInterruptState (
@ -213,7 +226,7 @@ Returns:
return EFI_SUCCESS;
}
STATIC
EFI_STATUS
EFIAPI
WinNtInit (
@ -247,7 +260,7 @@ Returns:
return EFI_UNSUPPORTED;
}
STATIC
EFI_STATUS
EFIAPI
WinNtRegisterInterruptHandler (
@ -293,7 +306,7 @@ Returns:
return EFI_UNSUPPORTED;
}
STATIC
EFI_STATUS
EFIAPI
WinNtGetTimerValue (
@ -333,7 +346,7 @@ Returns:
return EFI_UNSUPPORTED;
}
STATIC
EFI_STATUS
EFIAPI
WinNtSetMemoryAttributes (
@ -385,6 +398,114 @@ Returns:
}
VOID
CpuUpdateDataHub (
VOID
)
/*++
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;
UINT32 HeaderSize;
UINT32 TotalSize;
EFI_DATA_HUB_PROTOCOL *DataHub;
EFI_HII_PROTOCOL *Hii;
EFI_HII_HANDLE StringHandle;
EFI_HII_PACKAGES *PackageList;
STRING_REF Token;
//
// Locate DataHub protocol.
//
Status = gBS->LocateProtocol (&gEfiDataHubProtocolGuid, NULL, &DataHub);
if (EFI_ERROR (Status)) {
return;
}
//
// Locate DataHub protocol.
//
Status = gBS->LocateProtocol (&gEfiHiiProtocolGuid, NULL, &Hii);
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 ;
}
//
// Initialize strings to HII database
//
PackageList = PreparePackages (1, &gEfiProcessorProducerGuid, CpuStrings);
Status = Hii->NewPack (Hii, PackageList, &StringHandle);
ASSERT (!EFI_ERROR (Status));
FreePool (PackageList);
CopyMem (RecordBuffer.Raw, &mCpuDataRecordHeader, HeaderSize);
//
// Store processor version data record to data hub
//
Token = 0;
Status = Hii->NewString (Hii, NULL, StringHandle, &Token, (CHAR16 *)PcdGetPtr (PcdWinNtCpuModel));
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
);
//
// Store CPU frequency data record to data hub
//
RecordBuffer.DataRecord->DataRecordHeader.RecordType = ProcessorCoreFrequencyRecordType;
RecordBuffer.DataRecord->VariableRecord.ProcessorCoreFrequency.Value = (UINT16) StrDecimalToUintn (PcdGetPtr (PcdWinNtCpuSpeed));
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);
}
EFI_STATUS
EFIAPI
InitializeCpu (
@ -411,317 +532,20 @@ Returns:
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);
CpuUpdateDataHub ();
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,
&mCpuTemplate.Handle,
&gEfiCpuArchProtocolGuid, &mCpuTemplate.Cpu,
&gEfiCpuIoProtocolGuid, &mCpuTemplate.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
);
}
}

75
Nt32Pkg/CpuRuntimeDxe/CpuDriver.h
View File

@ -30,12 +30,14 @@ Abstract:
#include <Guid/DataHubRecords.h>
#include <Protocol/CpuIo.h>
#include <Protocol/WinNtIo.h>
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Library/HiiLibFramework.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/PcdLib.h>
extern UINT8 CpuStrings[];
@ -108,4 +110,77 @@ CpuIoServiceWrite (
);
EFI_STATUS
EFIAPI
InitializeCpu (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
);
EFI_STATUS
EFIAPI
WinNtFlushCpuDataCache (
IN EFI_CPU_ARCH_PROTOCOL *This,
IN EFI_PHYSICAL_ADDRESS Start,
IN UINT64 Length,
IN EFI_CPU_FLUSH_TYPE FlushType
);
EFI_STATUS
EFIAPI
WinNtEnableInterrupt (
IN EFI_CPU_ARCH_PROTOCOL *This
);
EFI_STATUS
EFIAPI
WinNtDisableInterrupt (
IN EFI_CPU_ARCH_PROTOCOL *This
);
EFI_STATUS
EFIAPI
WinNtGetInterruptState (
IN EFI_CPU_ARCH_PROTOCOL *This,
OUT BOOLEAN *State
);
EFI_STATUS
EFIAPI
WinNtInit (
IN EFI_CPU_ARCH_PROTOCOL *This,
IN EFI_CPU_INIT_TYPE InitType
);
EFI_STATUS
EFIAPI
WinNtRegisterInterruptHandler (
IN EFI_CPU_ARCH_PROTOCOL *This,
IN EFI_EXCEPTION_TYPE InterruptType,
IN EFI_CPU_INTERRUPT_HANDLER InterruptHandler
);
EFI_STATUS
EFIAPI
WinNtGetTimerValue (
IN EFI_CPU_ARCH_PROTOCOL *This,
IN UINT32 TimerIndex,
OUT UINT64 *TimerValue,
OUT UINT64 *TimerPeriod OPTIONAL
);
EFI_STATUS
EFIAPI
WinNtSetMemoryAttributes (
IN EFI_CPU_ARCH_PROTOCOL *This,
IN EFI_PHYSICAL_ADDRESS BaseAddress,
IN UINT64 Length,
IN UINT64 Attributes
);
#endif

335
Nt32Pkg/CpuRuntimeDxe/CpuIo.c
View File

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

6
Nt32Pkg/CpuRuntimeDxe/CpuRuntimeDxe.inf
View File

@ -50,8 +50,6 @@
DebugLib
[Guids]
gEfiWinNtCPUSpeedGuid # SOMETIMES_CONSUMED
gEfiWinNtCPUModelGuid # SOMETIMES_CONSUMED
gEfiProcessorSubClassGuid # SOMETIMES_CONSUMED
gEfiProcessorProducerGuid # SOMETIMES_CONSUMED
@ -63,5 +61,9 @@
gEfiCpuIoProtocolGuid # PROTOCOL ALWAYS_PRODUCED
gEfiCpuArchProtocolGuid # PROTOCOL ALWAYS_PRODUCED
[PcdsDynamic.common]
PcdWinNtCpuSpeed|gEfiNt32PkgTokenSpaceGuid
PcdWinNtCpuModel|gEfiNt32PkgTokenSpaceGuid
[Depex]
gEfiDataHubProtocolGuid AND gEfiHiiProtocolGuid

BIN
Nt32Pkg/MiscSubClassPlatformDxe/MiscBaseBoardManufacturer.uni
View File

Binary file not shown.

BIN
Nt32Pkg/MiscSubClassPlatformDxe/MiscBiosVendor.uni
View File

Binary file not shown.

BIN
Nt32Pkg/MiscSubClassPlatformDxe/MiscChassisManufacturer.uni
View File

Binary file not shown.

BIN
Nt32Pkg/MiscSubClassPlatformDxe/MiscOemString.uni
View File

Binary file not shown.

BIN
Nt32Pkg/MiscSubClassPlatformDxe/MiscPortInternalConnectorDesignator.uni
View File

Binary file not shown.

18
Nt32Pkg/MiscSubClassPlatformDxe/MiscSubClassPlatformDxe.inf
View File

@ -54,15 +54,6 @@
MiscSubclassDriver.h
MiscDevicePath.h
MiscSubclassDriver.uni
MiscSystemSlotDesignation.uni
MiscSystemOptionString.uni
MiscSystemManufacturer.uni
MiscSystemLanguageString.uni
MiscPortInternalConnectorDesignator.uni
MiscOemString.uni
MiscChassisManufacturer.uni
MiscBiosVendor.uni
MiscBaseBoardManufacturer.uni
CommonHeader.h
[Packages]
@ -81,20 +72,23 @@
HiiLibFramework
DebugLib
BaseLib
PcdLib
[Guids]
gEfiWinNtMemoryGuid # SOMETIMES_CONSUMED
gEfiProcessorSubClassGuid # SOMETIMES_CONSUMED
gEfiMiscSubClassGuid # SOMETIMES_CONSUMED
gEfiMemoryProducerGuid # SOMETIMES_CONSUMED
gEfiMemorySubClassGuid # SOMETIMES_CONSUMED
gEfiWinNtMemoryGuid # SOMETIMES_CONSUMED
[Protocols]
gEfiWinNtIoProtocolGuid # PROTOCOL_NOTIFY SOMETIMES_CONSUMED
gEfiHiiProtocolGuid # PROTOCOL ALWAYS_CONSUMED
gEfiDataHubProtocolGuid # PROTOCOL ALWAYS_CONSUMED
[PcdsDynamic.common]
PcdWinNtMemorySize|gEfiNt32PkgTokenSpaceGuid
[Depex]
gEfiDataHubProtocolGuid AND gEfiHiiProtocolGuid
gEfiDataHubProtocolGuid AND gEfiHiiProtocolGuid

1
Nt32Pkg/MiscSubClassPlatformDxe/MiscSubclassDriver.h
View File

@ -36,6 +36,7 @@ Abstract:
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/DevicePathLib.h>
#include <Library/PcdLib.h>
#include <MiscDevicePath.h>

328
Nt32Pkg/MiscSubClassPlatformDxe/MiscSubclassDriverEntryPoint.c
View File

@ -25,12 +25,6 @@ Abstract:
extern UINT8 MiscSubclassStrings[];
VOID
EFIAPI
WinNtIoProtocolNotifyFunction (
IN EFI_EVENT Event,
IN VOID *Context
);
//
//
@ -70,7 +64,7 @@ Returns:
--*/
{
EFI_MISC_SUBCLASS_DRIVER_DATA MiscSubclass;
EFI_STATUS EfiStatus;
EFI_STATUS Status;
//
// Do nothing if data parameters are not valid.
@ -103,7 +97,7 @@ Returns:
//
// Log Data Hub record.
//
EfiStatus = DataHub->LogData (
Status = DataHub->LogData (
DataHub,
&gEfiMiscSubClassGuid,
&gEfiMiscSubClassGuid,
@ -112,16 +106,16 @@ Returns:
sizeof (EFI_SUBCLASS_TYPE1_HEADER) + RecordLen
);
if (EFI_ERROR (EfiStatus)) {
if (EFI_ERROR (Status)) {
DEBUG (
(EFI_D_ERROR,
"LogData(%d bytes) == %r\n",
sizeof (EFI_SUBCLASS_TYPE1_HEADER) + RecordLen,
EfiStatus)
Status)
);
}
return EfiStatus;
return Status;
}
@ -152,16 +146,17 @@ Returns:
--*/
{
EFI_MISC_SUBCLASS_DRIVER_DATA RecordData;
EFI_DATA_HUB_PROTOCOL *DataHub;
EFI_HII_PROTOCOL *Hii;
EFI_HII_PACKAGES *PackageList;
EFI_HII_HANDLE HiiHandle;
EFI_STATUS EfiStatus;
UINTN Index;
BOOLEAN LogRecordData;
EFI_EVENT Event;
VOID *Registration;
EFI_MISC_SUBCLASS_DRIVER_DATA RecordData;
EFI_DATA_HUB_PROTOCOL *DataHub;
EFI_HII_PROTOCOL *Hii;
EFI_HII_PACKAGES *PackageList;
EFI_HII_HANDLE HiiHandle;
EFI_STATUS Status;
UINTN Index;
BOOLEAN LogRecordData;
EFI_MEMORY_SUBCLASS_DRIVER_DATA MemorySubClassData;
UINT64 TotalMemorySize;
CHAR16 *Nt32MemString;
//
@ -175,11 +170,11 @@ Returns:
//
// Locate data hub protocol.
//
EfiStatus = gBS->LocateProtocol (&gEfiDataHubProtocolGuid, NULL, &DataHub);
Status = gBS->LocateProtocol (&gEfiDataHubProtocolGuid, NULL, &DataHub);
if (EFI_ERROR (EfiStatus)) {
DEBUG ((EFI_D_ERROR, "Could not locate DataHub protocol. %r\n", EfiStatus));
return EfiStatus;
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Could not locate DataHub protocol. %r\n", Status));
return Status;
} else if (DataHub == NULL) {
DEBUG ((EFI_D_ERROR, "LocateProtocol(DataHub) returned NULL pointer!\n"));
return EFI_DEVICE_ERROR;
@ -187,11 +182,11 @@ Returns:
//
// Locate hii protocol.
//
EfiStatus = gBS->LocateProtocol (&gEfiHiiProtocolGuid, NULL, &Hii);
Status = gBS->LocateProtocol (&gEfiHiiProtocolGuid, NULL, &Hii);
if (EFI_ERROR (EfiStatus)) {
DEBUG ((EFI_D_ERROR, "Could not locate Hii protocol. %r\n", EfiStatus));
return EfiStatus;
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Could not locate Hii protocol. %r\n", Status));
return Status;
} else if (Hii == NULL) {
DEBUG ((EFI_D_ERROR, "LocateProtocol(Hii) returned NULL pointer!\n"));
return EFI_DEVICE_ERROR;
@ -200,12 +195,12 @@ Returns:
// Add our default strings to the HII database. They will be modified later.
//
PackageList = PreparePackages (1, &gEfiMiscSubClassGuid, MiscSubclassStrings);
EfiStatus = Hii->NewPack (Hii, PackageList, &HiiHandle);
Status = Hii->NewPack (Hii, PackageList, &HiiHandle);
FreePool (PackageList);
if (EFI_ERROR (EfiStatus)) {
DEBUG ((EFI_D_ERROR, "Could not log default strings to Hii. %r\n", EfiStatus));
return EfiStatus;
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Could not log default strings to Hii. %r\n", Status));
return Status;
}
//
//
@ -250,7 +245,7 @@ Returns:
//
// Log RecordData to Data Hub.
//
EfiStatus = DataHub->LogData (
Status = DataHub->LogData (
DataHub,
&gEfiMiscSubClassGuid,
&gEfiMiscSubClassGuid,
@ -259,12 +254,12 @@ Returns:
sizeof (EFI_SUBCLASS_TYPE1_HEADER) + mMiscSubclassDataTable[Index].RecordLen
);
if (EFI_ERROR (EfiStatus)) {
if (EFI_ERROR (Status)) {
DEBUG (
(EFI_D_ERROR,
"LogData(%d bytes) == %r\n",
sizeof (EFI_SUBCLASS_TYPE1_HEADER) + mMiscSubclassDataTable[Index].RecordLen,
EfiStatus)
Status)
);
}
@ -276,29 +271,16 @@ Returns:
// is no more data to log.
//
for (;;) {
//
//
//
EfiStatus = (*mMiscSubclassDataTable[Index].Function)
(
mMiscSubclassDataTable[Index].RecordType, &mMiscSubclassDataTable[Index].RecordLen, &RecordData.Record, &
LogRecordData
);
//
//
//
if (EFI_ERROR (EfiStatus)) {
Status = (*mMiscSubclassDataTable[Index].Function)(mMiscSubclassDataTable[Index].RecordType, &mMiscSubclassDataTable[Index].RecordLen, &RecordData.Record, &LogRecordData);
if (EFI_ERROR (Status)) {
break;
}
if (!LogRecordData) {
break;
}
//
//
//
EfiStatus = DataHub->LogData (
Status = DataHub->LogData (
DataHub,
&gEfiMiscSubClassGuid,
&gEfiMiscSubClassGuid,
@ -307,212 +289,62 @@ Returns:
sizeof (EFI_SUBCLASS_TYPE1_HEADER) + mMiscSubclassDataTable[Index].RecordLen
);
if (EFI_ERROR (EfiStatus)) {
if (EFI_ERROR (Status)) {
DEBUG (
(EFI_D_ERROR,
"LogData(%d bytes) == %r\n",
sizeof (EFI_SUBCLASS_TYPE1_HEADER) + mMiscSubclassDataTable[Index].RecordLen,
EfiStatus)
Status)
);
}
}
}
//
// Install notify function to fetch memory data through WinNtIo protocol and store to data hub.
//
EfiStatus = gBS->CreateEvent (
EVT_NOTIFY_SIGNAL,
TPL_CALLBACK,
WinNtIoProtocolNotifyFunction,
ImageHandle,
&Event
);
ASSERT (!EFI_ERROR (EfiStatus));
EfiStatus = gBS->RegisterProtocolNotify (
&gEfiWinNtIoProtocolGuid,
Event,
&Registration
);
ASSERT (!EFI_ERROR (EfiStatus));
//
// Log Memory Size info based on PCD setting.
//
MemorySubClassData.Header.Instance = 1;
MemorySubClassData.Header.SubInstance = EFI_SUBCLASS_INSTANCE_NON_APPLICABLE;
MemorySubClassData.Header.RecordType = EFI_MEMORY_ARRAY_START_ADDRESS_RECORD_NUMBER;
//
// Process Memory String in form size!size ...
// So 64!64 is 128 MB
//
Nt32MemString = PcdGetPtr (PcdWinNtMemorySize);
for (TotalMemorySize = 0; *Nt32MemString != '\0';) {
TotalMemorySize += StrDecimalToUint64 (Nt32MemString);
while (*Nt32MemString != '\0') {
if (*Nt32MemString == '!') {
Nt32MemString++;
break;
}
Nt32MemString++;
}
}
MemorySubClassData.Record.ArrayStartAddress.MemoryArrayStartAddress = 0;
MemorySubClassData.Record.ArrayStartAddress.MemoryArrayEndAddress = LShiftU64 (TotalMemorySize, 20) - 1;
MemorySubClassData.Record.ArrayStartAddress.PhysicalMemoryArrayLink.ProducerName = gEfiMemoryProducerGuid;
MemorySubClassData.Record.ArrayStartAddress.PhysicalMemoryArrayLink.Instance = 1;
MemorySubClassData.Record.ArrayStartAddress.PhysicalMemoryArrayLink.SubInstance = EFI_SUBCLASS_INSTANCE_NON_APPLICABLE;
MemorySubClassData.Record.ArrayStartAddress.MemoryArrayPartitionWidth = 0;
//
// Store memory size data record to data hub.
//
Status = DataHub->LogData (
DataHub,
&gEfiMemorySubClassGuid,
&gEfiMemoryProducerGuid,
EFI_DATA_RECORD_CLASS_DATA,
&MemorySubClassData,
sizeof (EFI_SUBCLASS_TYPE1_HEADER) + sizeof (EFI_MEMORY_ARRAY_START_ADDRESS_DATA)
);
return EFI_SUCCESS;
}
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 memory size data to data hub.
Arguments:
Event - Event whose notification function is being invoked.
Context - Pointer to the notification function's context.
Returns:
EFI_STATUS.
--*/
{
EFI_STATUS Status;
EFI_MEMORY_SUBCLASS_DRIVER_DATA MemorySubClassData;
EFI_DATA_RECORD_HEADER *Record;
EFI_SUBCLASS_TYPE1_HEADER *DataHeader;
UINTN HandleCount;
UINTN HandleIndex;
UINT64 MonotonicCount;
BOOLEAN RecordFound;
EFI_HANDLE *HandleBuffer;
EFI_WIN_NT_IO_PROTOCOL *WinNtIo;
EFI_DATA_HUB_PROTOCOL *DataHub;
UINT64 TotalMemorySize;
DataHub = NULL;
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 DataHub protocol.
//
Status = gBS->LocateProtocol (&gEfiDataHubProtocolGuid, NULL, &DataHub);
if (EFI_ERROR (Status)) {
return ;
}
//
// Search the Handle array to find the meory size 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, &gEfiWinNtMemoryGuid)
) {
//
// 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 == EFI_MEMORY_ARRAY_START_ADDRESS_RECORD_NUMBER)
) {
RecordFound = TRUE;
}
}
} while (MonotonicCount != 0);
if (RecordFound) {
RecordFound = FALSE;
continue;
}
//
// Initialize data record.
//
MemorySubClassData.Header.Instance = 1;
MemorySubClassData.Header.SubInstance = EFI_SUBCLASS_INSTANCE_NON_APPLICABLE;
MemorySubClassData.Header.RecordType = EFI_MEMORY_ARRAY_START_ADDRESS_RECORD_NUMBER;
TotalMemorySize = (UINT64) Atoi (WinNtIo->EnvString);
MemorySubClassData.Record.ArrayStartAddress.MemoryArrayStartAddress = 0;
MemorySubClassData.Record.ArrayStartAddress.MemoryArrayEndAddress = LShiftU64 (TotalMemorySize, 20) - 1;
MemorySubClassData.Record.ArrayStartAddress.PhysicalMemoryArrayLink.ProducerName = gEfiMemoryProducerGuid;
MemorySubClassData.Record.ArrayStartAddress.PhysicalMemoryArrayLink.Instance = 1;
MemorySubClassData.Record.ArrayStartAddress.PhysicalMemoryArrayLink.SubInstance = EFI_SUBCLASS_INSTANCE_NON_APPLICABLE;
MemorySubClassData.Record.ArrayStartAddress.MemoryArrayPartitionWidth = 0;
//
// Store memory size data record to data hub.
//
Status = DataHub->LogData (
DataHub,
&gEfiMemorySubClassGuid,
&gEfiMemoryProducerGuid,
EFI_DATA_RECORD_CLASS_DATA,
&MemorySubClassData,
sizeof (EFI_SUBCLASS_TYPE1_HEADER) + sizeof (EFI_MEMORY_ARRAY_START_ADDRESS_DATA)
);
}
gBS->CloseProtocol (
HandleBuffer[HandleIndex],
&gEfiWinNtIoProtocolGuid,
Context,
NULL
);
}
}

BIN
Nt32Pkg/MiscSubClassPlatformDxe/MiscSystemLanguageString.uni
View File

Binary file not shown.

BIN
Nt32Pkg/MiscSubClassPlatformDxe/MiscSystemManufacturer.uni
View File

Binary file not shown.

BIN
Nt32Pkg/MiscSubClassPlatformDxe/MiscSystemOptionString.uni
View File

Binary file not shown.

BIN
Nt32Pkg/MiscSubClassPlatformDxe/MiscSystemSlotDesignation.uni
View File

Binary file not shown.

3
Nt32Pkg/Nt32Pkg.dec
View File

@ -59,9 +59,6 @@
################################################################################
[Guids.common]
gEfiWinNtPassThroughGuid = { 0xCC664EB8, 0x3C24, 0x4086, { 0xB6, 0xF6, 0x34, 0xE8, 0x56, 0xBC, 0xE3, 0x6E }}
gEfiWinNtCPUSpeedGuid = { 0xD4F29055, 0xE1FB, 0x11D4, { 0xBD, 0x0D, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81 }}
gEfiWinNtCPUModelGuid = { 0xBEE9B6CE, 0x2F8A, 0x11D4, { 0xBD, 0x0D, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81 }}
gEfiWinNtMemoryGuid = { 0x99042912, 0x122A, 0x11D4, { 0xBD, 0x0D, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81 }}
gEfiWinNtConsoleGuid = { 0xBA73672C, 0xA5D3, 0x11D4, { 0xBD, 0x00, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81 }}
gEfiWinNtUgaGuid = { 0xAB248E99, 0xABE1, 0x11D4, { 0xBD, 0x0D, 0x00, 0x80, 0xC7, 0x3C, 0x88, 0x81 }}
gEfiWinNtGopGuid = { 0x4e11e955, 0xccca, 0x11d4, { 0xbd, 0x0d, 0x00, 0x80, 0xc7, 0x3c, 0x88, 0x81 }}

10
Nt32Pkg/Nt32Pkg.dsc
View File

@ -329,14 +329,14 @@
################################################################################
[PcdsDynamicDefault.common.DEFAULT]
PcdWinNtCpuSpeed|gEfiNt32PkgTokenSpaceGuid|L"3000"|8
PcdWinNtSerialPort|gEfiNt32PkgTokenSpaceGuid|L"COM1!COM2"|18
PcdWinNtFileSystem|gEfiNt32PkgTokenSpaceGuid|L".!..\\..\\..\\..\\EdkShellBinPkg\\bin\\ia32\\Apps"|106
PcdWinNtGop|gEfiNt32PkgTokenSpaceGuid|L"UGA Window 1!UGA Window 2"|50
PcdWinNtConsole|gEfiNt32PkgTokenSpaceGuid|L"Bus Driver Console Window"|50
PcdWinNtMemorySize|gEfiNt32PkgTokenSpaceGuid|L"64!64"|10
PcdWinNtVirtualDisk|gEfiNt32PkgTokenSpaceGuid|L"FW;40960;512"|24
PcdWinNtCpuModel|gEfiNt32PkgTokenSpaceGuid|L"Intel(R) Processor Model"|48
PcdWinNtCpuModel|gEfiNt32PkgTokenSpaceGuid|L"NT32 Processor Emulation"|52
PcdWinNtCpuSpeed|gEfiNt32PkgTokenSpaceGuid|L"1234"|8
PcdWinNtMemorySize|gEfiNt32PkgTokenSpaceGuid|L"64!64"|10
PcdWinNtPhysicalDisk|gEfiNt32PkgTokenSpaceGuid|L"a:RW;2880;512!e:RW;262144;512"|58
PcdWinNtUga|gEfiNt32PkgTokenSpaceGuid|L"UGA Window 1!UGA Window 2"|50
PcdFlashNvStorageFtwSpareBase|gEfiMdeModulePkgTokenSpaceGuid|0x0
@ -428,5 +428,5 @@
$(WORKSPACE)/MdeModulePkg/Application/HelloWorld/HelloWorld.inf
[BuildOptions]
MSFT:DEBUG_*_IA32_DLINK_FLAGS = /EXPORT:InitializeDriver=_ModuleEntryPoint /ALIGN:4096 /SUBSYSTEM:CONSOLE
MSFT:RELEASE_*_IA32_DLINK_FLAGS = /ALIGN:4096
MSFT:DEBUG_*_IA32_DLINK_FLAGS = /EXPORT:InitializeDriver=_ModuleEntryPoint /ALIGN:4096 /SUBSYSTEM:CONSOLE
MSFT:RELEASE_*_IA32_DLINK_FLAGS = /ALIGN:4096

62
Nt32Pkg/PlatformBdsDxe/PlatformData.c
View File

@ -186,62 +186,6 @@ NT_ISA_SERIAL_DEVICE_PATH gNtSerialDevicePath1 = {
gEndEntire
};
NT_PLATFORM_CPU_MODEL_VIRTUAL_DEVICE_PATH gCpuModelDevicePath = {
{
HARDWARE_DEVICE_PATH,
HW_VENDOR_DP,
(UINT8) (sizeof (VENDOR_DEVICE_PATH)),
(UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8),
EFI_WIN_NT_THUNK_PROTOCOL_GUID
},
{
HARDWARE_DEVICE_PATH,
HW_VENDOR_DP,
(UINT8) (sizeof (WIN_NT_VENDOR_DEVICE_PATH_NODE)),
(UINT8) ((sizeof (WIN_NT_VENDOR_DEVICE_PATH_NODE)) >> 8),
EFI_WIN_NT_CPU_MODEL_GUID,
0
},
gEndEntire
};
NT_PLATFORM_CPU_SPEED_VIRTUAL_DEVICE_PATH gCpuSpeedDevicePath = {
{
HARDWARE_DEVICE_PATH,
HW_VENDOR_DP,
(UINT8) (sizeof (VENDOR_DEVICE_PATH)),
(UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8),
EFI_WIN_NT_THUNK_PROTOCOL_GUID
},
{
HARDWARE_DEVICE_PATH,
HW_VENDOR_DP,
(UINT8) (sizeof (WIN_NT_VENDOR_DEVICE_PATH_NODE)),
(UINT8) ((sizeof (WIN_NT_VENDOR_DEVICE_PATH_NODE)) >> 8),
EFI_WIN_NT_CPU_SPEED_GUID,
0
},
gEndEntire
};
NT_PLATFORM_MEMORY_VIRTUAL_DEVICE_PATH gMemoryDevicePath = {
{
HARDWARE_DEVICE_PATH,
HW_VENDOR_DP,
(UINT8) (sizeof (VENDOR_DEVICE_PATH)),
(UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8),
EFI_WIN_NT_THUNK_PROTOCOL_GUID
},
{
HARDWARE_DEVICE_PATH,
HW_VENDOR_DP,
(UINT8) (sizeof (WIN_NT_VENDOR_DEVICE_PATH_NODE)),
(UINT8) ((sizeof (WIN_NT_VENDOR_DEVICE_PATH_NODE)) >> 8),
EFI_WIN_NT_MEMORY_GUID,
0
},
gEndEntire
};
//
// Predefined platform default console device path
@ -285,8 +229,4 @@ EFI_DEVICE_PATH_PROTOCOL *gPlatformDriverOption[] = { NULL };
//
// Predefined platform connect sequence
//
EFI_DEVICE_PATH_PROTOCOL *gPlatformConnectSequence[] = {
(EFI_DEVICE_PATH_PROTOCOL *) &gCpuModelDevicePath,
(EFI_DEVICE_PATH_PROTOCOL *) &gCpuSpeedDevicePath,
(EFI_DEVICE_PATH_PROTOCOL *) &gMemoryDevicePath
};
EFI_DEVICE_PATH_PROTOCOL *gPlatformConnectSequence[] = { NULL };

50
Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.c
View File

@ -284,10 +284,10 @@ Returns:
WriteProtected = (BOOLEAN) (*Str == 'O');
Str = GetNextElementPastTerminator (Str, ';');
NumberOfBlocks = Atoi (Str);
NumberOfBlocks = StrDecimalToUintn (Str);
if (NumberOfBlocks != 0) {
Str = GetNextElementPastTerminator (Str, ';');
BlockSize = Atoi (Str);
BlockSize = StrDecimalToUintn (Str);
if (BlockSize != 0) {
//
// If we get here the variable is valid so do the work.
@ -1063,52 +1063,6 @@ WinNtBlockIoResetBlock (
return EFI_SUCCESS;
}
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++;
}
//
// Convert ot a Number
//
Number = 0;
while (*Str != '\0') {
if ((*Str >= '0') && (*Str <= '9')) {
Number = (Number * 10) +*Str - '0';
} else {
break;
}
Str++;
}
return Number;
}
EFI_STATUS
SetFilePointer64 (

5
Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriver.c
View File

@ -150,10 +150,7 @@ static NT_PCD_ENTRY mPcdEnvironment[] = {
PcdToken(PcdWinNtSerialPort), &gEfiWinNtSerialPortGuid,
PcdToken(PcdWinNtFileSystem), &gEfiWinNtFileSystemGuid,
PcdToken(PcdWinNtVirtualDisk), &gEfiWinNtVirtualDisksGuid,
PcdToken(PcdWinNtPhysicalDisk), &gEfiWinNtPhysicalDisksGuid,
PcdToken(PcdWinNtCpuModel), &gEfiWinNtCPUModelGuid,
PcdToken(PcdWinNtCpuSpeed), &gEfiWinNtCPUSpeedGuid,
PcdToken(PcdWinNtMemorySize), &gEfiWinNtMemoryGuid
PcdToken(PcdWinNtPhysicalDisk), &gEfiWinNtPhysicalDisksGuid
};
/**

3
Nt32Pkg/WinNtBusDriverDxe/WinNtBusDriverDxe.inf
View File

@ -60,9 +60,6 @@
[Guids]
gEfiWinNtCPUSpeedGuid # ALWAYS_CONSUMED
gEfiWinNtCPUModelGuid # ALWAYS_CONSUMED
gEfiWinNtMemoryGuid # ALWAYS_CONSUMED
gEfiWinNtConsoleGuid # ALWAYS_CONSUMED
gEfiWinNtGopGuid # ALWAYS_CONSUMED
gEfiWinNtSerialPortGuid # ALWAYS_CONSUMED

13
Nt32Pkg/WinNtGopDxe/WinNtGop.h
View File

@ -304,18 +304,5 @@ WinNtGopDestroySimpleTextInForWindow (
;
/**
TODO: Add function description
@param String TODO: add argument description
@return TODO: add return values
**/
UINTN
Atoi (
IN CHAR16 *String
)
;
#endif

41
Nt32Pkg/WinNtGopDxe/WinNtGopDriver.c
View File

@ -335,44 +335,3 @@ WinNtGopDriverBindingStop (
return Status;
}
/**
Convert a unicode string to a UINTN
@param String Unicode string.
@return UINTN of the number represented by String.
**/
UINTN
Atoi (
CHAR16 *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;
}