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

Separate memory allocation for FPDT S3 performance table and boot performance table, save S3 performance table pointer to LockBox in FirmwarePerformanceDxe. Then FirmwarePerformancePei can use the pointer in LockBox. 

Signed-off-by: Star Zeng <star.zeng@intel.com>
Reviewed-by: Liming Gao <liming.gao@intel.com>

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@14369 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
lzeng14 2013-05-16 07:35:30 +00:00
parent e643951bc5
commit db91c62082
6 changed files with 196 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
MdeModulePkg/Include/Guid/FirmwarePerformance.h
View File

@ -1,7 +1,7 @@
/** @file /** @file
ACPI Firmware Performance Data Table (FPDT) implementation specific definitions. ACPI Firmware Performance Data Table (FPDT) implementation specific definitions.
Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR> Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
@ -50,6 +50,15 @@
#define EFI_FIRMWARE_PERFORMANCE_VARIABLE_NAME L"FirmwarePerformance" #define EFI_FIRMWARE_PERFORMANCE_VARIABLE_NAME L"FirmwarePerformance"
/// LockBox:
/// GUID - gFirmwarePerformanceS3PointerGuid
/// Data - S3 performance table pointer
///
#define FIRMWARE_PERFORMANCE_S3_POINTER_GUID \
{ \
0xdc65adc, 0xa973, 0x4130, { 0x8d, 0xf0, 0x2a, 0xdb, 0xeb, 0x9e, 0x4a, 0x31 } \
}
#pragma pack(1) #pragma pack(1)
/// ///
@ -95,7 +104,7 @@ typedef struct {
/// ///
/// Variable defined for FPDT implementation. /// Variable defined for FPDT implementation.
/// This Variable is produced by FPDT DXE module and consumed by FPDT PEIM. /// This Variable is produced by FPDT DXE module.
/// ///
typedef struct { typedef struct {
EFI_PHYSICAL_ADDRESS BootPerformanceTablePointer; ///< Pointer to Boot Performance Table. EFI_PHYSICAL_ADDRESS BootPerformanceTablePointer; ///< Pointer to Boot Performance Table.
@ -118,5 +127,6 @@ typedef struct {
} SMM_BOOT_RECORD_COMMUNICATE; } SMM_BOOT_RECORD_COMMUNICATE;
extern EFI_GUID gEfiFirmwarePerformanceGuid; extern EFI_GUID gEfiFirmwarePerformanceGuid;
extern EFI_GUID gFirmwarePerformanceS3PointerGuid;
#endif #endif

1
MdeModulePkg/MdeModulePkg.dec
View File

@ -246,6 +246,7 @@
## Guid for Firmware Performance Data Table (FPDT) implementation. ## Guid for Firmware Performance Data Table (FPDT) implementation.
# Include/Guid/FirmwarePerformance.h # Include/Guid/FirmwarePerformance.h
gEfiFirmwarePerformanceGuid = { 0xc095791a, 0x3001, 0x47b2, { 0x80, 0xc9, 0xea, 0xc7, 0x31, 0x9f, 0x2f, 0xa4 }} gEfiFirmwarePerformanceGuid = { 0xc095791a, 0x3001, 0x47b2, { 0x80, 0xc9, 0xea, 0xc7, 0x31, 0x9f, 0x2f, 0xa4 }}
gFirmwarePerformanceS3PointerGuid = { 0xdc65adc, 0xa973, 0x4130, { 0x8d, 0xf0, 0x2a, 0xdb, 0xeb, 0x9e, 0x4a, 0x31 }}
## Include/Guid/ExitBootServiceFailed.h ## Include/Guid/ExitBootServiceFailed.h
gEventExitBootServicesFailedGuid = { 0x4f6c5507, 0x232f, 0x4787, { 0xb9, 0x5e, 0x72, 0xf8, 0x62, 0x49, 0xc, 0xb1 } } gEventExitBootServicesFailedGuid = { 0x4f6c5507, 0x232f, 0x4787, { 0xb9, 0x5e, 0x72, 0xf8, 0x62, 0x49, 0xc, 0xb1 } }

220
MdeModulePkg/Universal/Acpi/FirmwarePerformanceDataTableDxe/FirmwarePerformanceDxe.c
View File

@ -21,6 +21,8 @@
#include <Protocol/ReportStatusCodeHandler.h> #include <Protocol/ReportStatusCodeHandler.h>
#include <Protocol/AcpiTable.h> #include <Protocol/AcpiTable.h>
#include <Protocol/SmmCommunication.h> #include <Protocol/SmmCommunication.h>
#include <Protocol/LockBox.h>
#include <Protocol/Variable.h>
#include <Guid/Acpi.h> #include <Guid/Acpi.h>
#include <Guid/FirmwarePerformance.h> #include <Guid/FirmwarePerformance.h>
@ -36,7 +38,8 @@
#include <Library/MemoryAllocationLib.h> #include <Library/MemoryAllocationLib.h>
#include <Library/PcdLib.h> #include <Library/PcdLib.h>
#include <Library/HobLib.h> #include <Library/HobLib.h>
#include <Library/PcdLib.h> #include <Library/LockBoxLib.h>
#include <Library/UefiLib.h>
// //
// ACPI table information used to initialize tables. // ACPI table information used to initialize tables.
@ -51,6 +54,7 @@
EFI_RSC_HANDLER_PROTOCOL *mRscHandlerProtocol = NULL; EFI_RSC_HANDLER_PROTOCOL *mRscHandlerProtocol = NULL;
BOOLEAN mLockBoxReady = FALSE;
EFI_EVENT mReadyToBootEvent; EFI_EVENT mReadyToBootEvent;
EFI_EVENT mLegacyBootEvent; EFI_EVENT mLegacyBootEvent;
EFI_EVENT mExitBootServicesEvent; EFI_EVENT mExitBootServicesEvent;
@ -206,6 +210,7 @@ FpdtAllocateReservedMemoryBelow4G (
EFI_STATUS Status; EFI_STATUS Status;
VOID *Buffer; VOID *Buffer;
Buffer = NULL;
Pages = EFI_SIZE_TO_PAGES (Size); Pages = EFI_SIZE_TO_PAGES (Size);
Address = 0xffffffff; Address = 0xffffffff;
@ -217,12 +222,106 @@ FpdtAllocateReservedMemoryBelow4G (
); );
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
if (!EFI_ERROR (Status)) {
Buffer = (VOID *) (UINTN) Address; Buffer = (VOID *) (UINTN) Address;
ZeroMem (Buffer, Size); ZeroMem (Buffer, Size);
}
return Buffer; return Buffer;
} }
/**
Callback function upon VariableArchProtocol and LockBoxProtocol
to allocate S3 performance table memory and save the pointer to LockBox.
@param[in] Event Event whose notification function is being invoked.
@param[in] Context Pointer to the notification function's context.
**/
VOID
EFIAPI
FpdtAllocateS3PerformanceTableMemory (
IN EFI_EVENT Event,
IN VOID *Context
)
{
EFI_STATUS Status;
VOID *Interface;
FIRMWARE_PERFORMANCE_VARIABLE PerformanceVariable;
UINTN Size;
EFI_PHYSICAL_ADDRESS S3PerformanceTablePointer;
if (mLockBoxReady && (mAcpiS3PerformanceTable != NULL)) {
//
// The memory for S3 performance table should have been ready,
// and the pointer should have been saved to LockBox, just return.
//
return;
}
if (!mLockBoxReady) {
Status = gBS->LocateProtocol (&gEfiLockBoxProtocolGuid, NULL, &Interface);
if (!EFI_ERROR (Status)) {
//
// LockBox services has been ready.
//
mLockBoxReady = TRUE;
}
}
if (mAcpiS3PerformanceTable == NULL) {
Status = gBS->LocateProtocol (&gEfiVariableArchProtocolGuid, NULL, &Interface);
if (!EFI_ERROR (Status)) {
//
// Try to allocate the same runtime buffer as last time boot.
//
ZeroMem (&PerformanceVariable, sizeof (PerformanceVariable));
Size = sizeof (PerformanceVariable);
Status = gRT->GetVariable (
EFI_FIRMWARE_PERFORMANCE_VARIABLE_NAME,
&gEfiFirmwarePerformanceGuid,
NULL,
&Size,
&PerformanceVariable
);
if (!EFI_ERROR (Status)) {
Status = gBS->AllocatePages (
AllocateAddress,
EfiReservedMemoryType,
EFI_SIZE_TO_PAGES (sizeof (S3_PERFORMANCE_TABLE)),
&PerformanceVariable.S3PerformanceTablePointer
);
if (!EFI_ERROR (Status)) {
mAcpiS3PerformanceTable = (S3_PERFORMANCE_TABLE *) (UINTN) PerformanceVariable.S3PerformanceTablePointer;
}
}
if (mAcpiS3PerformanceTable == NULL) {
//
// Fail to allocate at specified address, continue to allocate at any address.
//
mAcpiS3PerformanceTable = (S3_PERFORMANCE_TABLE *) FpdtAllocateReservedMemoryBelow4G (sizeof (S3_PERFORMANCE_TABLE));
}
DEBUG ((EFI_D_INFO, "FPDT: ACPI S3 Performance Table address = 0x%x\n", mAcpiS3PerformanceTable));
if (mAcpiS3PerformanceTable != NULL) {
CopyMem (mAcpiS3PerformanceTable, &mS3PerformanceTableTemplate, sizeof (mS3PerformanceTableTemplate));
}
}
}
if (mLockBoxReady && (mAcpiS3PerformanceTable != NULL)) {
//
// If LockBox services has been ready and memory for FPDT S3 performance table has been allocated,
// save the pointer to LockBox for use in S3 resume.
//
S3PerformanceTablePointer = (EFI_PHYSICAL_ADDRESS) (UINTN) mAcpiS3PerformanceTable;
Status = SaveLockBox (
&gFirmwarePerformanceS3PointerGuid,
&S3PerformanceTablePointer,
sizeof (EFI_PHYSICAL_ADDRESS)
);
ASSERT_EFI_ERROR (Status);
}
}
/** /**
Install ACPI Firmware Performance Data Table (FPDT). Install ACPI Firmware Performance Data Table (FPDT).
@ -236,15 +335,13 @@ InstallFirmwarePerformanceDataTable (
{ {
EFI_STATUS Status; EFI_STATUS Status;
EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol; EFI_ACPI_TABLE_PROTOCOL *AcpiTableProtocol;
EFI_PHYSICAL_ADDRESS Address;
UINTN Size; UINTN Size;
UINT8 *SmmBootRecordCommBuffer; UINT8 *SmmBootRecordCommBuffer;
EFI_SMM_COMMUNICATE_HEADER *SmmCommBufferHeader; EFI_SMM_COMMUNICATE_HEADER *SmmCommBufferHeader;
SMM_BOOT_RECORD_COMMUNICATE *SmmCommData; SMM_BOOT_RECORD_COMMUNICATE *SmmCommData;
UINTN CommSize; UINTN CommSize;
UINTN PerformanceRuntimeDataSize; UINTN BootPerformanceDataSize;
UINT8 *PerformanceRuntimeData; UINT8 *BootPerformanceData;
UINT8 *PerformanceRuntimeDataHead;
EFI_SMM_COMMUNICATION_PROTOCOL *Communication; EFI_SMM_COMMUNICATION_PROTOCOL *Communication;
FIRMWARE_PERFORMANCE_VARIABLE PerformanceVariable; FIRMWARE_PERFORMANCE_VARIABLE PerformanceVariable;
@ -299,15 +396,12 @@ InstallFirmwarePerformanceDataTable (
FreePool (SmmBootRecordCommBuffer); FreePool (SmmBootRecordCommBuffer);
// //
// Prepare memory for runtime Performance Record. // Prepare memory for Boot Performance table.
// Runtime performance records includes two tables S3 performance table and Boot performance table.
// S3 Performance table includes S3Resume and S3Suspend records.
// Boot Performance table includes BasicBoot record, and one or more appended Boot Records. // Boot Performance table includes BasicBoot record, and one or more appended Boot Records.
// //
PerformanceRuntimeData = NULL; BootPerformanceDataSize = sizeof (BOOT_PERFORMANCE_TABLE) + mBootRecordSize + PcdGet32 (PcdExtFpdtBootRecordPadSize);
PerformanceRuntimeDataSize = sizeof (S3_PERFORMANCE_TABLE) + sizeof (BOOT_PERFORMANCE_TABLE) + mBootRecordSize + PcdGet32 (PcdExtFpdtBootRecordPadSize);
if (SmmCommData != NULL) { if (SmmCommData != NULL) {
PerformanceRuntimeDataSize += SmmCommData->BootRecordSize; BootPerformanceDataSize += SmmCommData->BootRecordSize;
} }
// //
@ -323,88 +417,60 @@ InstallFirmwarePerformanceDataTable (
&PerformanceVariable &PerformanceVariable
); );
if (!EFI_ERROR (Status)) { if (!EFI_ERROR (Status)) {
Address = PerformanceVariable.S3PerformanceTablePointer;
Status = gBS->AllocatePages ( Status = gBS->AllocatePages (
AllocateAddress, AllocateAddress,
EfiReservedMemoryType, EfiReservedMemoryType,
EFI_SIZE_TO_PAGES (PerformanceRuntimeDataSize), EFI_SIZE_TO_PAGES (BootPerformanceDataSize),
&Address &PerformanceVariable.BootPerformanceTablePointer
); );
if (!EFI_ERROR (Status)) { if (!EFI_ERROR (Status)) {
PerformanceRuntimeData = (UINT8 *) (UINTN) Address; mAcpiBootPerformanceTable = (BOOT_PERFORMANCE_TABLE *) (UINTN) PerformanceVariable.BootPerformanceTablePointer;
} }
} }
if (PerformanceRuntimeData == NULL) { if (mAcpiBootPerformanceTable == NULL) {
// //
// Fail to allocate at specified address, continue to allocate at any address. // Fail to allocate at specified address, continue to allocate at any address.
// //
PerformanceRuntimeData = FpdtAllocateReservedMemoryBelow4G (PerformanceRuntimeDataSize); mAcpiBootPerformanceTable = (BOOT_PERFORMANCE_TABLE *) FpdtAllocateReservedMemoryBelow4G (BootPerformanceDataSize);
} }
DEBUG ((EFI_D_INFO, "FPDT: Performance Runtime Data address = 0x%x\n", PerformanceRuntimeData)); DEBUG ((EFI_D_INFO, "FPDT: ACPI Boot Performance Table address = 0x%x\n", mAcpiBootPerformanceTable));
if (PerformanceRuntimeData == NULL) { if (mAcpiBootPerformanceTable == NULL) {
if (SmmCommData != NULL && SmmCommData->BootRecordData != NULL) { if (SmmCommData != NULL && SmmCommData->BootRecordData != NULL) {
FreePool (SmmCommData->BootRecordData); FreePool (SmmCommData->BootRecordData);
} }
return EFI_OUT_OF_RESOURCES; if (mAcpiS3PerformanceTable != NULL) {
FreePages (mAcpiS3PerformanceTable, EFI_SIZE_TO_PAGES (sizeof (S3_PERFORMANCE_TABLE)));
} }
return EFI_OUT_OF_RESOURCES;
PerformanceRuntimeDataHead = PerformanceRuntimeData;
if (FeaturePcdGet (PcdFirmwarePerformanceDataTableS3Support)) {
//
// Prepare S3 Performance Table.
//
mAcpiS3PerformanceTable = (S3_PERFORMANCE_TABLE *) PerformanceRuntimeData;
CopyMem (mAcpiS3PerformanceTable, &mS3PerformanceTableTemplate, sizeof (mS3PerformanceTableTemplate));
PerformanceRuntimeData = PerformanceRuntimeData + mAcpiS3PerformanceTable->Header.Length;
DEBUG ((EFI_D_INFO, "FPDT: ACPI S3 Performance Table address = 0x%x\n", mAcpiS3PerformanceTable));
//
// Save S3 Performance Table address to Variable for use in Firmware Performance PEIM.
//
PerformanceVariable.S3PerformanceTablePointer = (EFI_PHYSICAL_ADDRESS) (UINTN) mAcpiS3PerformanceTable;
//
// Update S3 Performance Table Pointer in template.
//
mFirmwarePerformanceTableTemplate.S3PointerRecord.S3PerformanceTablePointer = (UINT64) PerformanceVariable.S3PerformanceTablePointer;
} else {
//
// Exclude S3 Performance Table Pointer from FPDT table template.
//
mFirmwarePerformanceTableTemplate.Header.Length -= sizeof (EFI_ACPI_5_0_FPDT_S3_PERFORMANCE_TABLE_POINTER_RECORD);
} }
// //
// Prepare Boot Performance Table. // Prepare Boot Performance Table.
// //
mAcpiBootPerformanceTable = (BOOT_PERFORMANCE_TABLE *) PerformanceRuntimeData; BootPerformanceData = (UINT8 *) mAcpiBootPerformanceTable;
// //
// Fill Basic Boot record to Boot Performance Table. // Fill Basic Boot record to Boot Performance Table.
// //
CopyMem (PerformanceRuntimeData, &mBootPerformanceTableTemplate, sizeof (mBootPerformanceTableTemplate)); CopyMem (mAcpiBootPerformanceTable, &mBootPerformanceTableTemplate, sizeof (mBootPerformanceTableTemplate));
PerformanceRuntimeData = PerformanceRuntimeData + mAcpiBootPerformanceTable->Header.Length; BootPerformanceData = BootPerformanceData + mAcpiBootPerformanceTable->Header.Length;
// //
// Fill Boot records from boot drivers. // Fill Boot records from boot drivers.
// //
CopyMem (PerformanceRuntimeData, mBootRecordBuffer, mBootRecordSize); CopyMem (BootPerformanceData, mBootRecordBuffer, mBootRecordSize);
mAcpiBootPerformanceTable->Header.Length += mBootRecordSize; mAcpiBootPerformanceTable->Header.Length += mBootRecordSize;
PerformanceRuntimeData = PerformanceRuntimeData + mBootRecordSize; BootPerformanceData = BootPerformanceData + mBootRecordSize;
if (SmmCommData != NULL && SmmCommData->BootRecordData != NULL) { if (SmmCommData != NULL && SmmCommData->BootRecordData != NULL) {
// //
// Fill Boot records from SMM drivers. // Fill Boot records from SMM drivers.
// //
CopyMem (PerformanceRuntimeData, SmmCommData->BootRecordData, SmmCommData->BootRecordSize); CopyMem (BootPerformanceData, SmmCommData->BootRecordData, SmmCommData->BootRecordSize);
FreePool (SmmCommData->BootRecordData); FreePool (SmmCommData->BootRecordData);
mAcpiBootPerformanceTable->Header.Length = (UINT32) (mAcpiBootPerformanceTable->Header.Length + SmmCommData->BootRecordSize); mAcpiBootPerformanceTable->Header.Length = (UINT32) (mAcpiBootPerformanceTable->Header.Length + SmmCommData->BootRecordSize);
PerformanceRuntimeData = PerformanceRuntimeData + SmmCommData->BootRecordSize; BootPerformanceData = BootPerformanceData + SmmCommData->BootRecordSize;
} }
// //
// Reserve space for boot records after ReadyToBoot.
//
PerformanceRuntimeData = PerformanceRuntimeData + PcdGet32 (PcdExtFpdtBootRecordPadSize);
DEBUG ((EFI_D_INFO, "FPDT: ACPI Boot Performance Table address = 0x%x\n", mAcpiBootPerformanceTable));
//
// Save Boot Performance Table address to Variable for use in S4 resume. // Save Boot Performance Table address to Variable for use in S4 resume.
// //
PerformanceVariable.BootPerformanceTablePointer = (EFI_PHYSICAL_ADDRESS) (UINTN) mAcpiBootPerformanceTable; PerformanceVariable.BootPerformanceTablePointer = (EFI_PHYSICAL_ADDRESS) (UINTN) mAcpiBootPerformanceTable;
@ -413,13 +479,21 @@ InstallFirmwarePerformanceDataTable (
// //
mFirmwarePerformanceTableTemplate.BootPointerRecord.BootPerformanceTablePointer = (UINT64) (UINTN) mAcpiBootPerformanceTable; mFirmwarePerformanceTableTemplate.BootPointerRecord.BootPerformanceTablePointer = (UINT64) (UINTN) mAcpiBootPerformanceTable;
//
// Save S3 Performance Table address to Variable for use in S4 resume.
//
PerformanceVariable.S3PerformanceTablePointer = (EFI_PHYSICAL_ADDRESS) (UINTN) mAcpiS3PerformanceTable;
//
// Update S3 Performance Table Pointer in template.
//
mFirmwarePerformanceTableTemplate.S3PointerRecord.S3PerformanceTablePointer = (UINT64) (UINTN) mAcpiS3PerformanceTable;
// //
// Save Runtime Performance Table pointers to Variable. // Save Runtime Performance Table pointers to Variable.
// //
Status = gRT->SetVariable ( Status = gRT->SetVariable (
EFI_FIRMWARE_PERFORMANCE_VARIABLE_NAME, EFI_FIRMWARE_PERFORMANCE_VARIABLE_NAME,
&gEfiFirmwarePerformanceGuid, &gEfiFirmwarePerformanceGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS, EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
sizeof (PerformanceVariable), sizeof (PerformanceVariable),
&PerformanceVariable &PerformanceVariable
); );
@ -436,7 +510,10 @@ InstallFirmwarePerformanceDataTable (
&mFirmwarePerformanceTableTemplateKey &mFirmwarePerformanceTableTemplateKey
); );
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
FreePool (PerformanceRuntimeDataHead); FreePages (mAcpiBootPerformanceTable, EFI_SIZE_TO_PAGES (BootPerformanceDataSize));
if (mAcpiS3PerformanceTable != NULL) {
FreePages (mAcpiS3PerformanceTable, EFI_SIZE_TO_PAGES (sizeof (S3_PERFORMANCE_TABLE)));
}
mAcpiBootPerformanceTable = NULL; mAcpiBootPerformanceTable = NULL;
mAcpiS3PerformanceTable = NULL; mAcpiS3PerformanceTable = NULL;
return Status; return Status;
@ -703,6 +780,7 @@ FirmwarePerformanceDxeEntryPoint (
EFI_STATUS Status; EFI_STATUS Status;
EFI_HOB_GUID_TYPE *GuidHob; EFI_HOB_GUID_TYPE *GuidHob;
FIRMWARE_SEC_PERFORMANCE *Performance; FIRMWARE_SEC_PERFORMANCE *Performance;
VOID *Registration;
// //
// Get Report Status Code Handler Protocol. // Get Report Status Code Handler Protocol.
@ -769,5 +847,31 @@ FirmwarePerformanceDxeEntryPoint (
DEBUG ((EFI_D_ERROR, "FPDT: WARNING: SEC Performance Data Hob not found, ResetEnd will be set to 0!\n")); DEBUG ((EFI_D_ERROR, "FPDT: WARNING: SEC Performance Data Hob not found, ResetEnd will be set to 0!\n"));
} }
if (FeaturePcdGet (PcdFirmwarePerformanceDataTableS3Support)) {
//
// Register callback function upon VariableArchProtocol and LockBoxProtocol
// to allocate S3 performance table memory and save the pointer to LockBox.
//
EfiCreateProtocolNotifyEvent (
&gEfiVariableArchProtocolGuid,
TPL_CALLBACK,
FpdtAllocateS3PerformanceTableMemory,
NULL,
&Registration
);
EfiCreateProtocolNotifyEvent (
&gEfiLockBoxProtocolGuid,
TPL_CALLBACK,
FpdtAllocateS3PerformanceTableMemory,
NULL,
&Registration
);
} else {
//
// Exclude S3 Performance Table Pointer from FPDT table template.
//
mFirmwarePerformanceTableTemplate.Header.Length -= sizeof (EFI_ACPI_5_0_FPDT_S3_PERFORMANCE_TABLE_POINTER_RECORD);
}
return EFI_SUCCESS; return EFI_SUCCESS;
} }

7
MdeModulePkg/Universal/Acpi/FirmwarePerformanceDataTableDxe/FirmwarePerformanceDxe.inf
View File

@ -5,7 +5,7 @@
# for Firmware Basic Boot Performance Record and other boot performance records, # for Firmware Basic Boot Performance Record and other boot performance records,
# and install FPDT to ACPI table. # and install FPDT to ACPI table.
# #
# Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR> # Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>
# This program and the accompanying materials # This program and the accompanying materials
# are licensed and made available under the terms and conditions of the BSD License # 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 # which accompanies this distribution. The full text of the license may be found at
@ -48,11 +48,15 @@
MemoryAllocationLib MemoryAllocationLib
PcdLib PcdLib
HobLib HobLib
LockBoxLib
UefiLib
[Protocols] [Protocols]
gEfiAcpiTableProtocolGuid ## SOMETIMES_CONSUMES gEfiAcpiTableProtocolGuid ## SOMETIMES_CONSUMES
gEfiRscHandlerProtocolGuid ## CONSUMES gEfiRscHandlerProtocolGuid ## CONSUMES
gEfiSmmCommunicationProtocolGuid ## SOMETIMES_CONSUMES gEfiSmmCommunicationProtocolGuid ## SOMETIMES_CONSUMES
gEfiVariableArchProtocolGuid ## SOMETIMES_CONSUMES
gEfiLockBoxProtocolGuid ## SOMETIMES_CONSUMES
[Guids] [Guids]
gEfiEventExitBootServicesGuid ## CONSUMES gEfiEventExitBootServicesGuid ## CONSUMES
@ -65,6 +69,7 @@
gEfiFirmwarePerformanceGuid ## SOMETIMES_CONSUMES ## Hob gEfiFirmwarePerformanceGuid ## SOMETIMES_CONSUMES ## Hob
gEfiFirmwarePerformanceGuid ## SOMETIMES_CONSUMES ## SmiHandler gEfiFirmwarePerformanceGuid ## SOMETIMES_CONSUMES ## SmiHandler
gEfiFirmwarePerformanceGuid ## SOMETIMES_CONSUMES ## StatusCode Data gEfiFirmwarePerformanceGuid ## SOMETIMES_CONSUMES ## StatusCode Data
gFirmwarePerformanceS3PointerGuid ## SOMETIMES_PRODUCES # SaveLockBox
[Pcd] [Pcd]
gEfiMdeModulePkgTokenSpaceGuid.PcdProgressCodeOsLoaderLoad gEfiMdeModulePkgTokenSpaceGuid.PcdProgressCodeOsLoaderLoad

37
MdeModulePkg/Universal/Acpi/FirmwarePerformanceDataTablePei/FirmwarePerformancePei.c
View File

@ -7,7 +7,7 @@
This module register report status code listener to collect performance data This module register report status code listener to collect performance data
for S3 Resume Performance Record on S3 resume boot path. for S3 Resume Performance Record on S3 resume boot path.
Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR> Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
@ -20,7 +20,6 @@
#include <PiPei.h> #include <PiPei.h>
#include <Ppi/ReadOnlyVariable2.h>
#include <Ppi/ReportStatusCodeHandler.h> #include <Ppi/ReportStatusCodeHandler.h>
#include <Ppi/SecPerformance.h> #include <Ppi/SecPerformance.h>
@ -68,9 +67,8 @@ FpdtStatusCodeListenerPei (
{ {
EFI_STATUS Status; EFI_STATUS Status;
UINT64 CurrentTime; UINT64 CurrentTime;
EFI_PEI_READ_ONLY_VARIABLE2_PPI *VariableServices;
UINTN VarSize; UINTN VarSize;
FIRMWARE_PERFORMANCE_VARIABLE PerformanceVariable; EFI_PHYSICAL_ADDRESS S3PerformanceTablePointer;
S3_PERFORMANCE_TABLE *AcpiS3PerformanceTable; S3_PERFORMANCE_TABLE *AcpiS3PerformanceTable;
EFI_ACPI_5_0_FPDT_S3_RESUME_RECORD *AcpiS3ResumeRecord; EFI_ACPI_5_0_FPDT_S3_RESUME_RECORD *AcpiS3ResumeRecord;
UINT64 S3ResumeTotal; UINT64 S3ResumeTotal;
@ -90,33 +88,20 @@ FpdtStatusCodeListenerPei (
// //
CurrentTime = GetTimeInNanoSecond (GetPerformanceCounter ()); CurrentTime = GetTimeInNanoSecond (GetPerformanceCounter ());
Status = PeiServicesLocatePpi (
&gEfiPeiReadOnlyVariable2PpiGuid,
0,
NULL,
(VOID **) &VariableServices
);
ASSERT_EFI_ERROR (Status);
// //
// Update S3 Resume Performance Record. // Update S3 Resume Performance Record.
// //
VarSize = sizeof (FIRMWARE_PERFORMANCE_VARIABLE); S3PerformanceTablePointer = 0;
Status = VariableServices->GetVariable ( VarSize = sizeof (EFI_PHYSICAL_ADDRESS);
VariableServices, Status = RestoreLockBox (&gFirmwarePerformanceS3PointerGuid, &S3PerformanceTablePointer, &VarSize);
EFI_FIRMWARE_PERFORMANCE_VARIABLE_NAME, ASSERT_EFI_ERROR (Status);
&gEfiFirmwarePerformanceGuid,
NULL,
&VarSize,
&PerformanceVariable
);
if (EFI_ERROR (Status)) {
return Status;
}
AcpiS3PerformanceTable = (S3_PERFORMANCE_TABLE *) (UINTN) PerformanceVariable.S3PerformanceTablePointer; AcpiS3PerformanceTable = (S3_PERFORMANCE_TABLE *) (UINTN) S3PerformanceTablePointer;
ASSERT (AcpiS3PerformanceTable != NULL); ASSERT (AcpiS3PerformanceTable != NULL);
ASSERT (AcpiS3PerformanceTable->Header.Signature == EFI_ACPI_5_0_FPDT_S3_PERFORMANCE_TABLE_SIGNATURE); if (AcpiS3PerformanceTable->Header.Signature != EFI_ACPI_5_0_FPDT_S3_PERFORMANCE_TABLE_SIGNATURE) {
DEBUG ((EFI_D_ERROR, "FPDT S3 performance data in ACPI memory get corrupted\n"));
return EFI_ABORTED;
}
AcpiS3ResumeRecord = &AcpiS3PerformanceTable->S3Resume; AcpiS3ResumeRecord = &AcpiS3PerformanceTable->S3Resume;
AcpiS3ResumeRecord->FullResume = CurrentTime; AcpiS3ResumeRecord->FullResume = CurrentTime;
// //

4
MdeModulePkg/Universal/Acpi/FirmwarePerformanceDataTablePei/FirmwarePerformancePei.inf
View File

@ -7,7 +7,7 @@
# This module register report status code listener to collect performance data # This module register report status code listener to collect performance data
# for S3 Resume Performance Record on S3 resume boot path. # for S3 Resume Performance Record on S3 resume boot path.
# #
# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR> # Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>
# This program and the accompanying materials # This program and the accompanying materials
# are licensed and made available under the terms and conditions of the BSD License # 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 # which accompanies this distribution. The full text of the license may be found at
@ -52,11 +52,11 @@
[Ppis] [Ppis]
gEfiPeiRscHandlerPpiGuid ## CONSUMES gEfiPeiRscHandlerPpiGuid ## CONSUMES
gEfiPeiReadOnlyVariable2PpiGuid ## SOMETIMES_CONSUMES
gPeiSecPerformancePpiGuid ## CONSUMES gPeiSecPerformancePpiGuid ## CONSUMES
[Guids] [Guids]
gEfiFirmwarePerformanceGuid ## CONSUMES gEfiFirmwarePerformanceGuid ## CONSUMES
gFirmwarePerformanceS3PointerGuid ## CONSUMES
[FeaturePcd] [FeaturePcd]
gEfiMdeModulePkgTokenSpaceGuid.PcdFirmwarePerformanceDataTableS3Support gEfiMdeModulePkgTokenSpaceGuid.PcdFirmwarePerformanceDataTableS3Support