/**
Performs platform specific initialization required for the CPU to access
the hardware associated with a SerialPortLib instance. This function does
not intiailzie the serial port hardware itself. Instead, it initializes
hardware devices that are required for the CPU to access the serial port
hardware. This function may be called more than once.
@retval RETURN_SUCCESS The platform specific initialization succeeded.
@retval RETURN_DEVICE_ERROR The platform specific initialization could not be completed.
**/
RETURN_STATUS
EFIAPI
PlatformHookSerialPortInitialize (
VOID
)
{
RETURN_STATUS Status;
UINT32 SerialRegBase;
UINT32 SerialRegAccessType;
Status = CbParseSerialInfo (&SerialRegBase, &SerialRegAccessType, NULL);
if (RETURN_ERROR (Status)) {
return Status;
}
if (SerialRegAccessType == 2) { //MMIO
Status = PcdSetBoolS (PcdSerialUseMmio, TRUE);
} else { //IO
Status = PcdSetBoolS (PcdSerialUseMmio, FALSE);
}
if (RETURN_ERROR (Status)) {
return Status;
}
Status = PcdSet64S (PcdSerialRegisterBase, (UINT64) SerialRegBase);
if (RETURN_ERROR (Status)) {
return Status;
}
return RETURN_SUCCESS;
}
/**
Perform Platform PEI initialization.
@param FileHandle Handle of the file being invoked.
@param PeiServices Describes the list of possible PEI Services.
@return EFI_SUCCESS The PEIM initialized successfully.
**/
EFI_STATUS
EFIAPI
InitializePlatform (
IN EFI_PEI_FILE_HANDLE FileHandle,
IN CONST EFI_PEI_SERVICES **PeiServices
)
{
EFI_STATUS Status;
DEBUG ((EFI_D_ERROR, "Platform PEIM Loaded\n"));
DebugDumpCmos ();
XenDetect ();
if (QemuFwCfgS3Enabled ()) {
DEBUG ((EFI_D_INFO, "S3 support was detected on QEMU\n"));
mS3Supported = TRUE;
Status = PcdSetBoolS (PcdAcpiS3Enable, TRUE);
ASSERT_EFI_ERROR (Status);
}
S3Verification ();
BootModeInitialization ();
AddressWidthInitialization ();
MaxCpuCountInitialization ();
PublishPeiMemory ();
InitializeRamRegions ();
if (mXen) {
DEBUG ((EFI_D_INFO, "Xen was detected\n"));
InitializeXen ();
}
//
// Query Host Bridge DID
//
mHostBridgeDevId = PciRead16 (OVMF_HOSTBRIDGE_DID);
if (mBootMode != BOOT_ON_S3_RESUME) {
ReserveEmuVariableNvStore ();
PeiFvInitialization ();
MemMapInitialization ();
NoexecDxeInitialization ();
}
MiscInitialization ();
InstallFeatureControlCallback ();
return EFI_SUCCESS;
}
/**
Perform the memory test base on the memory test intensive level,
and update the memory resource.
@param Level The memory test intensive level.
@retval EFI_STATUS Success test all the system memory and update
the memory resource
**/
EFI_STATUS
EFIAPI
BdsMemoryTest (
IN EXTENDMEM_COVERAGE_LEVEL Level
)
{
EFI_STATUS Status;
EFI_STATUS KeyStatus;
EFI_STATUS InitStatus;
EFI_STATUS ReturnStatus;
BOOLEAN RequireSoftECCInit;
EFI_GENERIC_MEMORY_TEST_PROTOCOL *GenMemoryTest;
UINT64 TestedMemorySize;
UINT64 TotalMemorySize;
UINTN TestPercent;
UINT64 PreviousValue;
BOOLEAN ErrorOut;
BOOLEAN TestAbort;
EFI_INPUT_KEY Key;
CHAR16 StrPercent[80];
CHAR16 *StrTotalMemory;
CHAR16 *Pos;
CHAR16 *TmpStr;
EFI_GRAPHICS_OUTPUT_BLT_PIXEL Foreground;
EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background;
EFI_GRAPHICS_OUTPUT_BLT_PIXEL Color;
BOOLEAN IsFirstBoot;
UINT32 TempData;
UINTN StrTotalMemorySize;
ReturnStatus = EFI_SUCCESS;
ZeroMem (&Key, sizeof (EFI_INPUT_KEY));
StrTotalMemorySize = 128;
Pos = AllocateZeroPool (StrTotalMemorySize);
if (Pos == NULL) {
return ReturnStatus;
}
StrTotalMemory = Pos;
TestedMemorySize = 0;
TotalMemorySize = 0;
PreviousValue = 0;
ErrorOut = FALSE;
TestAbort = FALSE;
SetMem (&Foreground, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff);
SetMem (&Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0x0);
SetMem (&Color, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff);
RequireSoftECCInit = FALSE;
Status = gBS->LocateProtocol (
&gEfiGenericMemTestProtocolGuid,
NULL,
(VOID **) &GenMemoryTest
);
if (EFI_ERROR (Status)) {
FreePool (Pos);
return EFI_SUCCESS;
}
InitStatus = GenMemoryTest->MemoryTestInit (
GenMemoryTest,
Level,
&RequireSoftECCInit
);
if (InitStatus == EFI_NO_MEDIA) {
//
// The PEI codes also have the relevant memory test code to check the memory,
// it can select to test some range of the memory or all of them. If PEI code
// checks all the memory, this BDS memory test will has no not-test memory to
// do the test, and then the status of EFI_NO_MEDIA will be returned by
// "MemoryTestInit". So it does not need to test memory again, just return.
//
FreePool (Pos);
return EFI_SUCCESS;
}
if (!FeaturePcdGet(PcdBootlogoOnlyEnable)) {
TmpStr = GetStringById (STRING_TOKEN (STR_ESC_TO_SKIP_MEM_TEST));
if (TmpStr != NULL) {
PrintXY (10, 10, NULL, NULL, TmpStr);
FreePool (TmpStr);
}
} else {
DEBUG ((EFI_D_INFO, "Enter memory test.\n"));
}
do {
Status = GenMemoryTest->PerformMemoryTest (
GenMemoryTest,
&TestedMemorySize,
&TotalMemorySize,
&ErrorOut,
TestAbort
);
if (ErrorOut && (Status == EFI_DEVICE_ERROR)) {
TmpStr = GetStringById (STRING_TOKEN (STR_SYSTEM_MEM_ERROR));
if (TmpStr != NULL) {
PrintXY (10, 10, NULL, NULL, TmpStr);
FreePool (TmpStr);
}
ASSERT (0);
}
if (!FeaturePcdGet(PcdBootlogoOnlyEnable)) {
TempData = (UINT32) DivU64x32 (TotalMemorySize, 16);
TestPercent = (UINTN) DivU64x32 (
DivU64x32 (MultU64x32 (TestedMemorySize, 100), 16),
TempData
);
if (TestPercent != PreviousValue) {
UnicodeValueToString (StrPercent, 0, TestPercent, 0);
TmpStr = GetStringById (STRING_TOKEN (STR_MEMORY_TEST_PERCENT));
if (TmpStr != NULL) {
//
// TmpStr size is 64, StrPercent is reserved to 16.
//
StrnCatS (
StrPercent,
sizeof (StrPercent) / sizeof (CHAR16),
TmpStr,
sizeof (StrPercent) / sizeof (CHAR16) - StrLen (StrPercent) - 1
);
PrintXY (10, 10, NULL, NULL, StrPercent);
FreePool (TmpStr);
}
TmpStr = GetStringById (STRING_TOKEN (STR_PERFORM_MEM_TEST));
if (TmpStr != NULL) {
PlatformBdsShowProgress (
Foreground,
Background,
TmpStr,
Color,
TestPercent,
(UINTN) PreviousValue
);
FreePool (TmpStr);
}
}
PreviousValue = TestPercent;
} else {
DEBUG ((EFI_D_INFO, "Perform memory test (ESC to skip).\n"));
}
if (!PcdGetBool (PcdConInConnectOnDemand)) {
KeyStatus = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
if (!EFI_ERROR (KeyStatus) && (Key.ScanCode == SCAN_ESC)) {
if (!RequireSoftECCInit) {
if (!FeaturePcdGet(PcdBootlogoOnlyEnable)) {
TmpStr = GetStringById (STRING_TOKEN (STR_PERFORM_MEM_TEST));
if (TmpStr != NULL) {
PlatformBdsShowProgress (
Foreground,
Background,
TmpStr,
Color,
100,
(UINTN) PreviousValue
);
FreePool (TmpStr);
}
PrintXY (10, 10, NULL, NULL, L"100");
}
Status = GenMemoryTest->Finished (GenMemoryTest);
goto Done;
}
TestAbort = TRUE;
}
}
} while (Status != EFI_NOT_FOUND);
Status = GenMemoryTest->Finished (GenMemoryTest);
Done:
if (!FeaturePcdGet(PcdBootlogoOnlyEnable)) {
UnicodeValueToString (StrTotalMemory, COMMA_TYPE, TotalMemorySize, 0);
if (StrTotalMemory[0] == L',') {
StrTotalMemory++;
StrTotalMemorySize -= sizeof (CHAR16);
}
TmpStr = GetStringById (STRING_TOKEN (STR_MEM_TEST_COMPLETED));
if (TmpStr != NULL) {
StrnCatS (
StrTotalMemory,
StrTotalMemorySize / sizeof (CHAR16),
TmpStr,
StrTotalMemorySize / sizeof (CHAR16) - StrLen (StrTotalMemory) - 1
);
FreePool (TmpStr);
}
PrintXY (10, 10, NULL, NULL, StrTotalMemory);
PlatformBdsShowProgress (
Foreground,
Background,
StrTotalMemory,
Color,
100,
(UINTN) PreviousValue
);
} else {
DEBUG ((EFI_D_INFO, "%d bytes of system memory tested OK\r\n", TotalMemorySize));
}
FreePool (Pos);
//
// Use a DynamicHii type pcd to save the boot status, which is used to
// control configuration mode, such as FULL/MINIMAL/NO_CHANGES configuration.
//
IsFirstBoot = PcdGetBool(PcdBootState);
if (IsFirstBoot) {
Status = PcdSetBoolS(PcdBootState, FALSE);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Set PcdBootState to FALSE failed.\n"));
}
}
return ReturnStatus;
}