From ad1a179818e9eba78cbdce2694ff87e9228c48fd Mon Sep 17 00:00:00 2001 From: vanjeff Date: Fri, 29 Jun 2007 03:38:49 +0000 Subject: 1. add EdkSerialPortLibNull.inf 2. add StatusCode Dxe and Pei modules git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2877 6f19259b-4bc3-4df7-8a09-765794883524 --- .../IntelFrameworkModulePkg.dsc | 38 ++- .../Library/EdkSerialPortLibNull/CommonHeader.h | 31 ++ .../EdkSerialPortLibNull/EdkSerialPortLibNull.inf | 59 ++++ .../EdkSerialPortLibNull/EdkSerialPortLibNull.msa | 40 +++ .../EdkSerialPortLibNull/SerialPortLibNull.c | 85 ++++++ .../StatusCode/Dxe/Common/DxeStatusCodeCommon.c | 233 ++++++++++++++ .../Universal/StatusCode/Dxe/Common/StatusCode.dxs | 30 ++ .../Universal/StatusCode/Dxe/CommonHeader.h | 70 +++++ .../StatusCode/Dxe/DataHubStatusCodeWorker.c | 335 +++++++++++++++++++++ .../Universal/StatusCode/Dxe/DxeStatusCode.c | 160 ++++++++++ .../Universal/StatusCode/Dxe/DxeStatusCode.h | 245 +++++++++++++++ .../Universal/StatusCode/Dxe/DxeStatusCode.inf | 170 +++++++++++ .../Universal/StatusCode/Dxe/DxeStatusCode.msa | 184 +++++++++++ .../Universal/StatusCode/Dxe/EntryPoint.c | 59 ++++ .../StatusCode/Dxe/RtMemoryStatusCodeWorker.c | 125 ++++++++ .../StatusCode/Dxe/SerialStatusCodeWorker.c | 228 ++++++++++++++ .../Universal/StatusCode/Pei/CommonHeader.h | 44 +++ .../StatusCode/Pei/MemoryStausCodeWorker.c | 156 ++++++++++ .../Universal/StatusCode/Pei/PeiStatusCode.c | 151 ++++++++++ .../Universal/StatusCode/Pei/PeiStatusCode.h | 144 +++++++++ .../Universal/StatusCode/Pei/PeiStatusCode.inf | 140 +++++++++ .../Universal/StatusCode/Pei/PeiStatusCode.msa | 111 +++++++ .../StatusCode/Pei/SerialStatusCodeWorker.c | 174 +++++++++++ 23 files changed, 3010 insertions(+), 2 deletions(-) create mode 100644 IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/CommonHeader.h create mode 100644 IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/EdkSerialPortLibNull.inf create mode 100644 IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/EdkSerialPortLibNull.msa create mode 100644 IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/SerialPortLibNull.c create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Dxe/Common/DxeStatusCodeCommon.c create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Dxe/Common/StatusCode.dxs create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Dxe/CommonHeader.h create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DataHubStatusCodeWorker.c create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.c create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.h create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.inf create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.msa create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Dxe/EntryPoint.c create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Dxe/RtMemoryStatusCodeWorker.c create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Dxe/SerialStatusCodeWorker.c create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Pei/CommonHeader.h create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Pei/MemoryStausCodeWorker.c create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.c create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.h create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.inf create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.msa create mode 100644 IntelFrameworkModulePkg/Universal/StatusCode/Pei/SerialStatusCodeWorker.c (limited to 'IntelFrameworkModulePkg') diff --git a/IntelFrameworkModulePkg/IntelFrameworkModulePkg.dsc b/IntelFrameworkModulePkg/IntelFrameworkModulePkg.dsc index dc6278bdbf..e3cba061e1 100644 --- a/IntelFrameworkModulePkg/IntelFrameworkModulePkg.dsc +++ b/IntelFrameworkModulePkg/IntelFrameworkModulePkg.dsc @@ -9,7 +9,7 @@ # 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. # @@ -46,6 +46,20 @@ PrintLib|${WORKSPACE}/MdePkg/Library/BasePrintLib/BasePrintLib.inf TimerLib|${WORKSPACE}/MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf UefiDecompressLib|${WORKSPACE}/MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.inf + OemHookStatusCodeLib|${WORKSPACE}/IntelFrameworkModulePkg/Library/OemHookStatusCodeLibNull/OemHookStatusCodeLibNull.inf + SerialPortLib|${WORKSPACE}/IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/EdkSerialPortLibNull.inf + +[LibraryClasses.common.PEIM] + HobLib|$(WORKSPACE)/MdePkg/Library/PeiHobLib/PeiHobLib.inf + PeiServicesTablePointerLib|$(WORKSPACE)/MdePkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointerLib.inf + PcdLib|$(WORKSPACE)/MdePkg/Library/PeiPcdLib/PeiPcdLib.inf + IoLib|$(WORKSPACE)/MdePkg/Library/PeiIoLibCpuIo/PeiIoLibCpuIo.inf + DebugLib|$(WORKSPACE)/MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf + PeimEntryPoint|$(WORKSPACE)/MdePkg/Library/PeimEntryPoint/PeimEntryPoint.inf + PeiServicesLib|$(WORKSPACE)/MdePkg/Library/PeiServicesLib/PeiServicesLib.inf + BaseMemoryLib|$(WORKSPACE)/MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf + MemoryAllocationLib|$(WORKSPACE)/MdePkg/Library/PeiMemoryAllocationLib/PeiMemoryAllocationLib.inf + ReportStatusCodeLib|$(WORKSPACE)/IntelFrameworkPkg/Library/PeiReportStatusCodeLib/PeiReportStatusCodeLib.inf [LibraryClasses.common.DXE_DRIVER] HobLib|${WORKSPACE}/MdePkg/Library/DxeHobLib/DxeHobLib.inf @@ -63,6 +77,19 @@ FvbServiceLib|${WORKSPACE}/MdeModulePkg/Library/EdkFvbServiceLib/EdkFvbServiceLib.inf ReportStatusCodeLib|${WORKSPACE}/IntelFrameworkPkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf +[LibraryClasses.common.DXE_RUNTIME_DRIVER] + HobLib|${WORKSPACE}/MdePkg/Library/DxeHobLib/DxeHobLib.inf + MemoryAllocationLib|${WORKSPACE}/MdePkg/Library/DxeMemoryAllocationLib/DxeMemoryAllocationLib.inf + PcdLib|${WORKSPACE}/MdePkg/Library/DxePcdLib/DxePcdLib.inf + DxeServiceTableLib|${WORKSPACE}/MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.inf + UefiBootServicesTableLib|${WORKSPACE}/MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf + DebugLib|${WORKSPACE}/MdePkg/Library/UefiDebugLibConOut/UefiDebugLibConOut.inf + UefiDriverEntryPoint|${WORKSPACE}/MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf + UefiLib|${WORKSPACE}/MdePkg/Library/UefiLib/UefiLib.inf + UefiRuntimeLib|${WORKSPACE}/MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.inf + UefiRuntimeServicesTableLib|${WORKSPACE}/MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf + ReportStatusCodeLib|${WORKSPACE}/IntelFrameworkPkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf + ################################################################################ # # Pcd Section - list of all EDK II PCD Entries defined by this Platform @@ -108,7 +135,11 @@ PcdDebugPrintErrorLevel|gEfiMdePkgTokenSpaceGuid|0x80000000 PcdPciExpressBaseAddress|gEfiMdePkgTokenSpaceGuid|0xE0000000 PcdFSBClock|gEfiMdePkgTokenSpaceGuid|200000000 - + +[PcdsDynamic.common] + PcdStatusCodeMemorySize|gEfiIntelFrameworkModulePkgTokenSpaceGuid|1 + PcdStatusCodeRuntimeMemorySize|gEfiIntelFrameworkModulePkgTokenSpaceGuid|4 + ################################################################################ # # Components Section - list of all EDK II Modules needed by this Platform @@ -123,3 +154,6 @@ $(WORKSPACE)\IntelFrameworkModulePkg\Bus\Pci\IdeBus\Dxe\IdeBus.inf $(WORKSPACE)\IntelFrameworkModulePkg\Universal\DataHub\DataHub\Dxe\DataHub.inf $(WORKSPACE)\IntelFrameworkModulePkg\Universal\DataHub\DataHubStdErr\Dxe\DataHubStdErr.inf + $(WORKSPACE)\IntelFrameworkModulePkg\Universal\DataHub\DataHubStdErr\Dxe\DataHubStdErr.inf + $(WORKSPACE)\IntelFrameworkModulePkg\Universal\StatusCode\Dxe\DxeStatusCode.inf + $(WORKSPACE)\IntelFrameworkModulePkg\Universal\StatusCode\Pei\PeiStatusCode.inf diff --git a/IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/CommonHeader.h b/IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/CommonHeader.h new file mode 100644 index 0000000000..3097ab7907 --- /dev/null +++ b/IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/CommonHeader.h @@ -0,0 +1,31 @@ +/**@file + Common header file shared by all source files. + + This file includes package header files, library classes and protocol, PPI & GUID definitions. + + Copyright (c) 2006, Intel Corporation. + All rights reserved. This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +**/ + +#ifndef __COMMON_HEADER_H_ +#define __COMMON_HEADER_H_ + + +// +// The package level header files this module uses +// +#include +// +// The protocols, PPI and GUID defintions for this module +// +// +// The Library classes this module consumes +// +#include + +#endif diff --git a/IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/EdkSerialPortLibNull.inf b/IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/EdkSerialPortLibNull.inf new file mode 100644 index 0000000000..8a872d1471 --- /dev/null +++ b/IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/EdkSerialPortLibNull.inf @@ -0,0 +1,59 @@ +#/** @file +# Memory Status Code Library for UEFI drivers +# +# Lib to provide memory journal status code reporting Routines +# 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. +# +# +#**/ + +################################################################################ +# +# Defines Section - statements that will be processed to create a Makefile. +# +################################################################################ +[Defines] + INF_VERSION = 0x00010005 + BASE_NAME = EdkSerialPortLibNull + FILE_GUID = E4541241-8897-411a-91F8-7D7E45837146 + MODULE_TYPE = PEIM + VERSION_STRING = 1.0 + LIBRARY_CLASS = SerialPortLib + EDK_RELEASE_VERSION = 0x00020000 + EFI_SPECIFICATION_VERSION = 0x00020000 + + +# +# The following information is for reference only and not required by the build tools. +# +# VALID_ARCHITECTURES = IA32 X64 IPF EBC +# + +################################################################################ +# +# Sources Section - list of files that are required for the build to succeed. +# +################################################################################ + +[Sources.common] + SerialPortLibNull.c + + +################################################################################ +# +# Package Dependency Section - list of Package files that are required for +# this module. +# +################################################################################ + +[Packages] + MdePkg/MdePkg.dec + IntelFrameworkPkg/IntelFrameworkPkg.dec + diff --git a/IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/EdkSerialPortLibNull.msa b/IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/EdkSerialPortLibNull.msa new file mode 100644 index 0000000000..9c992ead07 --- /dev/null +++ b/IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/EdkSerialPortLibNull.msa @@ -0,0 +1,40 @@ + + + + EdkSerialPortLibNull + PEIM + E4541241-8897-411a-91F8-7D7E45837146 + 1.0 + Memory Status Code Library for UEFI drivers + Lib to provide memory journal status code reporting Routines + 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. + FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052 + + + IA32 X64 IPF EBC + false + EdkSerialPortLibNull + + + + SerialPortLib + + + + SerialPortLibNull.c + + + + + + + EFI_SPECIFICATION_VERSION 0x00020000 + EDK_RELEASE_VERSION 0x00020000 + + \ No newline at end of file diff --git a/IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/SerialPortLibNull.c b/IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/SerialPortLibNull.c new file mode 100644 index 0000000000..4782a9c2f8 --- /dev/null +++ b/IntelFrameworkModulePkg/Library/EdkSerialPortLibNull/SerialPortLibNull.c @@ -0,0 +1,85 @@ +/** @file + Serial I/O Port library functions with no library constructor/destructor + + 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: SerialPortLibNull.c + +**/ + +// +// The package level header files this module uses +// +#include +// +// The protocols, PPI and GUID defintions for this module +// +// +// The Library classes this module consumes +// +#include + +/* + + Programmed hardware of Serial port. + + @return Always return EFI_UNSUPPORTED. + +**/ +EFI_STATUS +EFIAPI +SerialPortInitialize ( + VOID + ) +{ + return EFI_UNSUPPORTED; +} + +/** + Write data to serial device. + + @param Buffer Point of data buffer which need to be writed. + @param NumberOfBytes Number of output bytes which are cached in Buffer. + + @retval 0 Write data failed. + @retval !0 Actual number of bytes writed to serial device. + +**/ +UINTN +EFIAPI +SerialPortWrite ( + IN UINT8 *Buffer, + IN UINTN NumberOfBytes +) +{ + return 0; +} + + +/** + Read data from serial device and save the datas in buffer. + + @param Buffer Point of data buffer which need to be writed. + @param NumberOfBytes Number of output bytes which are cached in Buffer. + + @retval 0 Read data failed. + @retval !0 Aactual number of bytes read from serial device. + +**/ +UINTN +EFIAPI +SerialPortRead ( + OUT UINT8 *Buffer, + IN UINTN NumberOfBytes +) +{ + return 0; +} + diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/Common/DxeStatusCodeCommon.c b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/Common/DxeStatusCodeCommon.c new file mode 100644 index 0000000000..54c9ac061b --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/Common/DxeStatusCodeCommon.c @@ -0,0 +1,233 @@ +/** @file + Status code driver for IA32/X64/EBC architecture. + + 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: DxeStatusCodeCommon.c + +**/ +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +#include "DxeStatusCode.h" + + +/** + Report status code to all supported device. + Calls into the workers which dispatches the platform specific + listeners. + + @param Type Indicates the type of status code being reported. + The type EFI_STATUS_CODE_TYPE is defined in "Related Definitions" below. + @param Value Describes the current status of a hardware or software entity. + This includes information about the class and subclass that is used to classify the entity + as well as an operation. For progress codes, the operation is the current activity. + For error codes, it is the exception. For debug codes, it is not defined at this time. + Type EFI_STATUS_CODE_VALUE is defined in "Related Definitions" below. + Specific values are discussed in the Intel? Platform Innovation Framework for EFI Status Code Specification. + @param Instance The enumeration of a hardware or software entity within the system. + A system may contain multiple entities that match a class/subclass pairing. + The instance differentiates between them. An instance of 0 indicates that instance + information is unavailable, not meaningful, or not relevant. Valid instance numbers start with 1. + @param CallerId This optional parameter may be used to identify the caller. + This parameter allows the status code driver to apply different rules to different callers. + @param Data This optional parameter may be used to pass additional data. + Type EFI_STATUS_CODE_DATA is defined in "Related Definitions" below. + The contents of this data type may have additional GUID-specific data. The standard GUIDs and + their associated data structures are defined in the Intel? Platform Innovation Framework for EFI Status Codes Specification. + + @return Always return EFI_SUCCESS. + +**/ +EFI_STATUS +EFIAPI +ReportDispatcher ( + IN EFI_STATUS_CODE_TYPE Type, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN EFI_GUID *CallerId OPTIONAL, + IN EFI_STATUS_CODE_DATA *Data OPTIONAL + ); + +// +// Declaration of status code protocol. +// +STATIC +EFI_STATUS_CODE_PROTOCOL mEfiStatusCodeProtocol = { + ReportDispatcher +}; + +// +// Delaration of DXE status code controller +// +DXE_STATUS_CODE_CONTROLLER gDxeStatusCode = { + // + // Initialize nest status as non nested. + // + 0, + {NULL, NULL} +}; + +/** + + Install the ReportStatusCode runtime service. + + @param ImageHandle Image handle of the loaded driver + @param SystemTable Pointer to the System Table + + @return The function always returns success. + +**/ +EFI_STATUS +DxeStatusCodeDriverEntry ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +{ + EFI_HANDLE Handle = NULL; + EFI_STATUS Status; + + // + // Dispatch initialization request to supported devices + // + InitializationDispatcherWorker (); + + // + // Install Status Code Architectural Protocol implementation as defined in Tiano + // Architecture Specification. + // + Status = gBS->InstallMultipleProtocolInterfaces ( + &Handle, + &gEfiStatusCodeRuntimeProtocolGuid, + &mEfiStatusCodeProtocol, + NULL + ); + ASSERT_EFI_ERROR (Status); + + return Status; +} + +/** + Report status code to all supported device. + Calls into the workers which dispatches the platform specific + listeners. + + @param CodeType Indicates the type of status code being reported. + The type EFI_STATUS_CODE_TYPE is defined in "Related Definitions" below. + @param Value Describes the current status of a hardware or software entity. + This includes information about the class and subclass that is used to classify the entity + as well as an operation. For progress codes, the operation is the current activity. + For error codes, it is the exception. For debug codes, it is not defined at this time. + Type EFI_STATUS_CODE_VALUE is defined in "Related Definitions" below. + Specific values are discussed in the Intel? Platform Innovation Framework for EFI Status Code Specification. + @param Instance The enumeration of a hardware or software entity within the system. + A system may contain multiple entities that match a class/subclass pairing. + The instance differentiates between them. An instance of 0 indicates that instance + information is unavailable, not meaningful, or not relevant. Valid instance numbers start with 1. + @param CallerId This optional parameter may be used to identify the caller. + This parameter allows the status code driver to apply different rules to different callers. + @param Data This optional parameter may be used to pass additional data. + Type EFI_STATUS_CODE_DATA is defined in "Related Definitions" below. + The contents of this data type may have additional GUID-specific data. The standard GUIDs and + their associated data structures are defined in the Intel? Platform Innovation Framework for EFI Status Codes Specification. + + @return Always return EFI_SUCCESS. + +**/ +EFI_STATUS +EFIAPI +ReportDispatcher ( + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN EFI_GUID *CallerId OPTIONAL, + IN EFI_STATUS_CODE_DATA *Data OPTIONAL + ) +{ + // + // Use atom operation to avoid the reentant of report. + // If current status is not zero, then the function is reentrancy. + // + if (1 == InterlockedCompareExchange32 (&gDxeStatusCode.StatusCodeNestStatus, 0, 1)) { + return EFI_DEVICE_ERROR; + } + + if (FeaturePcdGet (PcdStatusCodeUseEfiSerial) || FeaturePcdGet (PcdStatusCodeUseHardSerial)) { + SerialStatusCodeReportWorker ( + CodeType, + Value, + Instance, + CallerId, + Data + ); + } + if (FeaturePcdGet (PcdStatusCodeUseRuntimeMemory)) { + RtMemoryStatusCodeReportWorker ( + gDxeStatusCode.RtMemoryStatusCodeTable[PHYSICAL_MODE], + CodeType, + Value, + Instance + ); + } + if (FeaturePcdGet (PcdStatusCodeUseDataHub)) { + DataHubStatusCodeReportWorker ( + CodeType, + Value, + Instance, + CallerId, + Data + ); + } + if (FeaturePcdGet (PcdStatusCodeUseOEM)) { + OemHookStatusCodeReport ( + CodeType, + Value, + Instance, + CallerId, + Data + ); + } + + // + // Restore the nest status of report + // + InterlockedCompareExchange32 (&gDxeStatusCode.StatusCodeNestStatus, 1, 0); + + return EFI_SUCCESS; +} + + +/** + Virtual address change notification call back. It converts global pointer + to virtual address. + + @param Event Event whose notification function is being invoked. + @param Context Pointer to the notification function's context, which is + always zero in current implementation. + +**/ +VOID +EFIAPI +VirtualAddressChangeCallBack ( + IN EFI_EVENT Event, + IN VOID *Context + ) +{ + // + // Convert memory status code table to virtual address; + // + EfiConvertPointer ( + 0, + (VOID **) &gDxeStatusCode.RtMemoryStatusCodeTable[PHYSICAL_MODE] + ); +} + diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/Common/StatusCode.dxs b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/Common/StatusCode.dxs new file mode 100644 index 0000000000..e1c00539db --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/Common/StatusCode.dxs @@ -0,0 +1,30 @@ +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +#/*++ +# +# 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: +# +# StatusCode.dxs +# +# Abstract: +# +# Dependency expression source file. +# +#--*/ +#include + +DEPENDENCY_START + EFI_DATA_HUB_PROTOCOL_GUID AND EFI_CPU_IO_PROTOCOL_GUID +DEPENDENCY_END diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/CommonHeader.h b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/CommonHeader.h new file mode 100644 index 0000000000..32ebf0fbff --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/CommonHeader.h @@ -0,0 +1,70 @@ +/**@file + Common header file shared by all source files. + + This file includes package header files, library classes and protocol, PPI & GUID definitions. + + Copyright (c) 2006, Intel Corporation. + All rights reserved. This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +**/ + +#ifndef __COMMON_HEADER_H_ +#define __COMMON_HEADER_H_ + + +// +// The package level header files this module uses +// +#include +// +// The protocols, PPI and GUID defintions for this module +// +#include +#include +#include +#include +#include +#include +// +// The Library classes this module consumes +// +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// Declaration for callback Event. +// +VOID +EFIAPI +VirtualAddressChangeCallBack ( + IN EFI_EVENT Event, + IN VOID *Context + ); + +// +// Declaration for original Entry Point. +// +EFI_STATUS +EFIAPI +DxeStatusCodeDriverEntry ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ); + +#endif diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DataHubStatusCodeWorker.c b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DataHubStatusCodeWorker.c new file mode 100644 index 0000000000..0723af5d7c --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DataHubStatusCodeWorker.c @@ -0,0 +1,335 @@ +/** @file + Data Hub status code worker in DXE. + + 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: DataHubStatusCodeWorker.c + +**/ +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +#include "DxeStatusCode.h" + +// +// Initialize FIFO to cache records. +// +STATIC +LIST_ENTRY mRecordsFifo = INITIALIZE_LIST_HEAD_VARIABLE (mRecordsFifo); +STATIC +LIST_ENTRY mRecordsBuffer = INITIALIZE_LIST_HEAD_VARIABLE (mRecordsBuffer); +STATIC +EFI_EVENT mLogDataHubEvent; +// +// Cache data hub protocol. +// +STATIC +EFI_DATA_HUB_PROTOCOL *mDataHubProtocol; + + +/** + Return one DATAHUB_STATUSCODE_RECORD space. + The size of free record pool would be extend, if the pool is empty. + + + @retval NULL Can not allocate free memeory for record. + @retval !NULL Point to buffer of record. + +**/ +STATIC +DATAHUB_STATUSCODE_RECORD * +AcquireRecordBuffer ( + VOID + ) +{ + DATAHUB_STATUSCODE_RECORD *Record; + EFI_TPL CurrentTpl; + LIST_ENTRY *Node; + UINT32 Index; + + CurrentTpl = gBS->RaiseTPL (TPL_HIGH_LEVEL); + + if (!IsListEmpty (&mRecordsBuffer)) { + Node = GetFirstNode (&mRecordsBuffer); + RemoveEntryList (Node); + + Record = _CR (Node, DATAHUB_STATUSCODE_RECORD, Node); + } else { + if (CurrentTpl > TPL_NOTIFY) { + gBS->RestoreTPL (CurrentTpl); + return NULL; + } + + gBS->RestoreTPL (CurrentTpl); + Record = (DATAHUB_STATUSCODE_RECORD *) AllocateZeroPool (sizeof (DATAHUB_STATUSCODE_RECORD) * 16); + if (NULL == Record) { + return NULL; + } + + CurrentTpl = gBS->RaiseTPL (TPL_HIGH_LEVEL); + for (Index = 1; Index < 16; Index++) { + InsertTailList (&mRecordsBuffer, &Record[Index].Node); + } + } + + Record->Signature = DATAHUB_STATUS_CODE_SIGNATURE; + InsertTailList (&mRecordsFifo, &Record->Node); + + gBS->RestoreTPL (CurrentTpl); + + return Record; +} + + +/** + Retrieve one record from Records FIFO. The record would be removed from FIFO and + release to free record buffer. + + @return !NULL Point to record, which is ready to be logged. + @return NULL the FIFO of record is empty. + +**/ +STATIC +DATAHUB_STATUSCODE_RECORD * +RetrieveRecord ( + VOID + ) +{ + DATAHUB_STATUSCODE_RECORD *Record = NULL; + LIST_ENTRY *Node; + EFI_TPL CurrentTpl; + + CurrentTpl = gBS->RaiseTPL (TPL_HIGH_LEVEL); + + if (!IsListEmpty (&mRecordsFifo)) { + Node = GetFirstNode (&mRecordsFifo); + Record = CR (Node, DATAHUB_STATUSCODE_RECORD, Node, DATAHUB_STATUS_CODE_SIGNATURE); + + RemoveEntryList (&Record->Node); + InsertTailList (&mRecordsBuffer, &Record->Node); + Record->Signature = 0; + } + + gBS->RestoreTPL (CurrentTpl); + + return Record; +} + + +/** + Report status code into DataHub. + + @param CodeType Indicates the type of status code being reported. Type EFI_STATUS_CODE_TYPE is defined in "Related Definitions" below. + + @param Value Describes the current status of a hardware or software entity. + This included information about the class and subclass that is used to classify the entity + as well as an operation. For progress codes, the operation is the current activity. + For error codes, it is the exception. For debug codes, it is not defined at this time. + Type EFI_STATUS_CODE_VALUE is defined in "Related Definitions" below. + Specific values are discussed in the Intel? Platform Innovation Framework for EFI Status Code Specification. + + @param Instance The enumeration of a hardware or software entity within the system. + A system may contain multiple entities that match a class/subclass pairing. + The instance differentiates between them. An instance of 0 indicates that instance information is unavailable, + not meaningful, or not relevant. Valid instance numbers start with 1. + + + @param CallerId This optional parameter may be used to identify the caller. + This parameter allows the status code driver to apply different rules to different callers. + Type EFI_GUID is defined in InstallProtocolInterface() in the EFI 1.10 Specification. + + + @param Data This optional parameter may be used to pass additional data + + @retval EFI_OUT_OF_RESOURCES Can not acquire record buffer. + @retval EFI_DEVICE_ERROR EFI serial device can not work after ExitBootService() is called . + @retval EFI_SUCCESS Success to cache status code and signal log data event. + +**/ +EFI_STATUS +DataHubStatusCodeReportWorker ( + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN EFI_GUID *CallerId, + IN EFI_STATUS_CODE_DATA *Data OPTIONAL + ) +{ + DATAHUB_STATUSCODE_RECORD *Record; + UINT32 ErrorLevel; + VA_LIST Marker; + CHAR8 *Format; + UINTN CharCount; + + // + // See whether in runtime phase or not. + // + if (EfiAtRuntime ()) { + return EFI_DEVICE_ERROR; + } + + Record = AcquireRecordBuffer (); + if (Record == NULL) { + // + // There are no empty record buffer in private buffers + // + return EFI_OUT_OF_RESOURCES; + } + // + // Construct Data Hub Extended Data + // + Record->CodeType = CodeType; + Record->Value = Value; + Record->Instance = Instance; + + if (CallerId != NULL) { + CopyMem (&Record->CallerId, CallerId, sizeof (EFI_GUID)); + } + + if (Data != NULL) { + if (ReportStatusCodeExtractDebugInfo (Data, &ErrorLevel, &Marker, &Format)) { + CharCount = UnicodeVSPrintAsciiFormat ( + (CHAR16 *) Record->ExtendData, + EFI_STATUS_CODE_DATA_MAX_SIZE, + Format, + Marker + ); + // + // Change record data type from DebugType to String Type. + // + CopyGuid (&Record->Data.Type, &gEfiStatusCodeDataTypeStringGuid); + Record->Data.HeaderSize = Data->HeaderSize; + Record->Data.Size = (UINT16) ((CharCount + 1) * sizeof (CHAR16)); + } else { + // + // Copy status code data header + // + CopyMem (&Record->Data, Data, sizeof (EFI_STATUS_CODE_DATA)); + + if (Data->Size > EFI_STATUS_CODE_DATA_MAX_SIZE) { + Record->Data.Size = EFI_STATUS_CODE_DATA_MAX_SIZE; + } + CopyMem (Record->ExtendData, Data + 1, Record->Data.Size); + } + } + + gBS->SignalEvent (mLogDataHubEvent); + + return EFI_SUCCESS; +} + + +/** + The Event handler which will be notified to log data in Data Hub. + + @param Event Instance of the EFI_EVENT to signal whenever data is + available to be logged in the system. + @param Context Context of the event. + +**/ +STATIC +VOID +EFIAPI +LogDataHubEventCallBack ( + IN EFI_EVENT Event, + IN VOID *Context + ) +{ + DATAHUB_STATUSCODE_RECORD *Record; + UINT32 Size; + UINT64 DataRecordClass; + + // + // Log DataRecord in Data Hub. + // Journal records fifo to find all record entry. + // + while (1) { + Record = RetrieveRecord (); + if (Record == NULL) { + break; + } + // + // Add in the size of the header we added. + // + Size = sizeof (DATAHUB_STATUSCODE_RECORD) + (UINT32) Record->Data.Size; + + if ((Record->CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_PROGRESS_CODE) { + DataRecordClass = EFI_DATA_RECORD_CLASS_PROGRESS_CODE; + } else if ((Record->CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_ERROR_CODE) { + DataRecordClass = EFI_DATA_RECORD_CLASS_ERROR; + } else if ((Record->CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_DEBUG_CODE) { + DataRecordClass = EFI_DATA_RECORD_CLASS_DEBUG; + } else { + // + // Should never get here. + // + DataRecordClass = EFI_DATA_RECORD_CLASS_DEBUG | + EFI_DATA_RECORD_CLASS_ERROR | + EFI_DATA_RECORD_CLASS_DATA | + EFI_DATA_RECORD_CLASS_PROGRESS_CODE; + } + + // + // Log DataRecord in Data Hub + // + + mDataHubProtocol->LogData ( + mDataHubProtocol, + &gEfiStatusCodeGuid, + &gEfiStatusCodeRuntimeProtocolGuid, + DataRecordClass, + Record, + Size + ); + + } +} + + +/** + Initialize data hubstatus code. + Create a data hub listener. + + @return The function always return EFI_SUCCESS + +**/ +EFI_STATUS +DataHubStatusCodeInitializeWorker ( + VOID + ) +{ + EFI_STATUS Status; + + Status = gBS->LocateProtocol ( + &gEfiDataHubProtocolGuid, + NULL, + (VOID **) &mDataHubProtocol + ); + ASSERT_EFI_ERROR (Status); + + // + // Create a Notify Event to log data in Data Hub + // + Status = gBS->CreateEvent ( + EVT_NOTIFY_SIGNAL, + TPL_CALLBACK, + LogDataHubEventCallBack, + NULL, + &mLogDataHubEvent + ); + + ASSERT_EFI_ERROR (Status); + + return EFI_SUCCESS; +} + + diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.c b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.c new file mode 100644 index 0000000000..ec7ea8ba8c --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.c @@ -0,0 +1,160 @@ +/** @file + Status Code Architectural Protocol implementation as defined in Tiano + Architecture Specification. + + This driver has limited functionality at runtime and will not log to Data Hub + at runtime. + + Notes: + This driver assumes the following ReportStatusCode strategy: + PEI -> uses PeiReportStatusCode + DXE IPL -> uses PeiReportStatusCode + early DXE -> uses PeiReportStatusCode via HOB + DXE -> This driver + RT -> This driver + + 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: DxeStatusCode.c + +**/ + +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +#include "DxeStatusCode.h" + +/** + + Dispatch initialization request to sub status code devices based on + customized feature flags. + +**/ +VOID +InitializationDispatcherWorker ( + VOID + ) +{ + EFI_PEI_HOB_POINTERS Hob; + EFI_STATUS Status; + MEMORY_STATUSCODE_PACKET_HEADER *PacketHeader; + MEMORY_STATUSCODE_RECORD *Record; + UINTN ExpectedPacketIndex = 0; + UINTN Index; + VOID *HobStart; + + // + // If enable UseSerial, then initialize serial port. + // if enable UseRuntimeMemory, then initialize runtime memory status code worker. + // if enable UseDataHub, then initialize data hub status code worker. + // + if (FeaturePcdGet (PcdStatusCodeUseEfiSerial)) { + Status = EfiSerialStatusCodeInitializeWorker (); + ASSERT_EFI_ERROR (Status); + } + if (FeaturePcdGet (PcdStatusCodeUseHardSerial)) { + Status = SerialPortInitialize (); + ASSERT_EFI_ERROR (Status); + } + if (FeaturePcdGet (PcdStatusCodeUseRuntimeMemory)) { + Status = RtMemoryStatusCodeInitializeWorker (); + ASSERT_EFI_ERROR (Status); + } + if (FeaturePcdGet (PcdStatusCodeUseDataHub)) { + Status = DataHubStatusCodeInitializeWorker (); + ASSERT_EFI_ERROR (Status); + } + if (FeaturePcdGet (PcdStatusCodeUseOEM)) { + Status = OemHookStatusCodeInitialize (); + ASSERT_EFI_ERROR (Status); + } + + // + // Replay Status code which saved in GUID'ed HOB to all supported device. + // + + // + // Journal GUID'ed HOBs to find all record entry, if found, + // then output record to support replay device. + // + Hob.Raw = GetFirstGuidHob (&gMemoryStatusCodeRecordGuid); + HobStart = Hob.Raw; + while (Hob.Raw != NULL) { + PacketHeader = (MEMORY_STATUSCODE_PACKET_HEADER *) GET_GUID_HOB_DATA (Hob.Guid); + if (PacketHeader->PacketIndex == ExpectedPacketIndex) { + Record = (MEMORY_STATUSCODE_RECORD *) (PacketHeader + 1); + for (Index = 0; Index < PacketHeader->RecordIndex; Index++) { + // + // Dispatch records to devices based on feature flag. + // + if (FeaturePcdGet (PcdStatusCodeReplayInSerial) && + (FeaturePcdGet (PcdStatusCodeUseHardSerial) || + FeaturePcdGet (PcdStatusCodeUseEfiSerial))) { + SerialStatusCodeReportWorker ( + Record[Index].CodeType, + Record[Index].Value, + Record[Index].Instance, + NULL, + NULL + ); + } + if (FeaturePcdGet (PcdStatusCodeReplayInRuntimeMemory) && + FeaturePcdGet (PcdStatusCodeUseRuntimeMemory)) { + RtMemoryStatusCodeReportWorker ( + gDxeStatusCode.RtMemoryStatusCodeTable[PHYSICAL_MODE], + Record[Index].CodeType, + Record[Index].Value, + Record[Index].Instance + ); + } + if (FeaturePcdGet (PcdStatusCodeReplayInDataHub) && + FeaturePcdGet (PcdStatusCodeUseDataHub)) { + DataHubStatusCodeReportWorker ( + Record[Index].CodeType, + Record[Index].Value, + Record[Index].Instance, + NULL, + NULL + ); + } + if (FeaturePcdGet (PcdStatusCodeReplayInOEM) && + FeaturePcdGet (PcdStatusCodeUseOEM)) { + OemHookStatusCodeReport ( + Record[Index].CodeType, + Record[Index].Value, + Record[Index].Instance, + NULL, + NULL + ); + } + } + ExpectedPacketIndex++; + + // + // See whether there is gap of packet or not + // + if (NULL != HobStart) { + HobStart = NULL; + Hob.Raw = HobStart; + continue; + } + } else if (HobStart != NULL) { + // + // Cache the found packet for improve the performance + // + HobStart = Hob.Raw; + } + + Hob.Raw = GetNextGuidHob (&gMemoryStatusCodeRecordGuid, Hob.Raw); + } +} + diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.h b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.h new file mode 100644 index 0000000000..596c17313a --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.h @@ -0,0 +1,245 @@ +/*++ + + 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: + + DxeStatusCode.h + +Abstract: + + Header file of EFI DXE/RT Status Code. + +--*/ + +#ifndef __DXE_STATUS_CODE_H__ +#define __DXE_STATUS_CODE_H__ + +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +// +// Data hub worker definition +// +#define MAX_NUMBER_DATAHUB_RECORDS 1000 +#define DATAHUB_BYTES_PER_RECORD EFI_STATUS_CODE_DATA_MAX_SIZE +#define EMPTY_RECORD_TAG 0xFF +#define DATAHUB_STATUS_CODE_SIGNATURE EFI_SIGNATURE_32 ('B', 'D', 'H', 'S') + +// +// Address type of pointer. +// The point type always equal to PHYSICAL_MODE on IA32/X64/EBC architecture +// Otherwise, VIRTUAL_MODE/PHYSICAL_MODE would be used on Ipf architecture, +// +typedef enum { + PHYSICAL_MODE, + VIRTUAL_MODE +} PROCESSOR_MODE; + +typedef struct { + UINTN Signature; + LIST_ENTRY Node; + EFI_STATUS_CODE_TYPE CodeType; + EFI_STATUS_CODE_VALUE Value; + UINT32 Instance; + EFI_GUID CallerId; + EFI_STATUS_CODE_DATA Data; + UINT8 ExtendData[EFI_STATUS_CODE_DATA_MAX_SIZE]; +} DATAHUB_STATUSCODE_RECORD; + + +// +// Runtime memory status code worker definition +// +typedef struct { + UINT32 RecordIndex; + UINT32 NumberOfRecords; + UINT32 MaxRecordsNumber; +} RUNTIME_MEMORY_STATUSCODE_HEADER; + + +typedef struct { + // + // Report operation nest status. + // If it is set, then the report operation has nested. + // + UINT32 StatusCodeNestStatus; + // + // Runtime status code management header, the records buffer is following it. + // + RUNTIME_MEMORY_STATUSCODE_HEADER *RtMemoryStatusCodeTable[2]; +} DXE_STATUS_CODE_CONTROLLER; + + +/** + + Dispatch initialization request to sub status code devices based on + customized feature flags. + +**/ +VOID +InitializationDispatcherWorker ( + VOID + ); + + +/** + Initialize serial status code worker. + + @return The function always return EFI_SUCCESS + +**/ +EFI_STATUS +EfiSerialStatusCodeInitializeWorker ( + VOID + ); + + +/** + Convert status code value and extended data to readable ASCII string, send string to serial I/O device. + + @param CodeType Indicates the type of status code being reported. Type EFI_STATUS_CODE_TYPE is defined in "Related Definitions" below. + + @param Value Describes the current status of a hardware or software entity. + This included information about the class and subclass that is used to classify the entity + as well as an operation. For progress codes, the operation is the current activity. + For error codes, it is the exception. For debug codes, it is not defined at this time. + Type EFI_STATUS_CODE_VALUE is defined in "Related Definitions" below. + Specific values are discussed in the Intel? Platform Innovation Framework for EFI Status Code Specification. + + @param Instance The enumeration of a hardware or software entity within the system. + A system may contain multiple entities that match a class/subclass pairing. + The instance differentiates between them. An instance of 0 indicates that instance information is unavailable, + not meaningful, or not relevant. Valid instance numbers start with 1. + + + @param CallerId This optional parameter may be used to identify the caller. + This parameter allows the status code driver to apply different rules to different callers. + Type EFI_GUID is defined in InstallProtocolInterface() in the EFI 1.10 Specification. + + + @param Data This optional parameter may be used to pass additional data + + @retval EFI_SUCCESS Success to report status code to serial I/O. + @retval EFI_DEVICE_ERROR EFI serial device can not work after ExitBootService() is called . + +**/ +EFI_STATUS +SerialStatusCodeReportWorker ( + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN EFI_GUID *CallerId, + IN EFI_STATUS_CODE_DATA *Data OPTIONAL + ); + +/** + Initialize runtime memory status code. + + @return The function always return EFI_SUCCESS + +**/ +EFI_STATUS +RtMemoryStatusCodeInitializeWorker ( + VOID + ); + +/** + Report status code into runtime memory. If the runtime pool is full, roll back to the + first record and overwrite it. + + @param RtMemoryStatusCodeTable + Point to Runtime memory table header. + + @param CodeType Indicates the type of status code being reported. Type EFI_STATUS_CODE_TYPE is defined in "Related Definitions" below. + + @param Value Describes the current status of a hardware or software entity. + This included information about the class and subclass that is used to classify the entity + as well as an operation. For progress codes, the operation is the current activity. + For error codes, it is the exception. For debug codes, it is not defined at this time. + Type EFI_STATUS_CODE_VALUE is defined in "Related Definitions" below. + Specific values are discussed in the Intel? Platform Innovation Framework for EFI Status Code Specification. + + @param Instance The enumeration of a hardware or software entity within the system. + A system may contain multiple entities that match a class/subclass pairing. + The instance differentiates between them. An instance of 0 indicates that instance information is unavailable, + not meaningful, or not relevant. Valid instance numbers start with 1. + + @return The function always return EFI_SUCCESS. + +**/ +EFI_STATUS +RtMemoryStatusCodeReportWorker ( + RUNTIME_MEMORY_STATUSCODE_HEADER *RtMemoryStatusCodeTable, + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance + ); + +/** + Initialize data hubstatus code. + Create a data hub listener. + + @return The function always return EFI_SUCCESS + +**/ +EFI_STATUS +DataHubStatusCodeInitializeWorker ( + VOID + ); + + +/** + Report status code into DataHub. + + @param CodeType Indicates the type of status code being reported. Type EFI_STATUS_CODE_TYPE is defined in "Related Definitions" below. + + @param Value Describes the current status of a hardware or software entity. + This included information about the class and subclass that is used to classify the entity + as well as an operation. For progress codes, the operation is the current activity. + For error codes, it is the exception. For debug codes, it is not defined at this time. + Type EFI_STATUS_CODE_VALUE is defined in "Related Definitions" below. + Specific values are discussed in the Intel? Platform Innovation Framework for EFI Status Code Specification. + + @param Instance The enumeration of a hardware or software entity within the system. + A system may contain multiple entities that match a class/subclass pairing. + The instance differentiates between them. An instance of 0 indicates that instance information is unavailable, + not meaningful, or not relevant. Valid instance numbers start with 1. + + + @param CallerId This optional parameter may be used to identify the caller. + This parameter allows the status code driver to apply different rules to different callers. + Type EFI_GUID is defined in InstallProtocolInterface() in the EFI 1.10 Specification. + + + @param Data This optional parameter may be used to pass additional data + + @retval EFI_OUT_OF_RESOURCES Can not acquire record buffer. + @retval EFI_DEVICE_ERROR EFI serial device can not work after ExitBootService() is called . + @retval EFI_SUCCESS Success to cache status code and signal log data event. + +**/ +EFI_STATUS +DataHubStatusCodeReportWorker ( + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN EFI_GUID *CallerId, + IN EFI_STATUS_CODE_DATA *Data OPTIONAL + ); + +// +// declaration of DXE status code controller. +// +extern DXE_STATUS_CODE_CONTROLLER gDxeStatusCode; + +#endif diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.inf b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.inf new file mode 100644 index 0000000000..6470814110 --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.inf @@ -0,0 +1,170 @@ +#/** @file +# DXE status code driver. +# +# Status Code Architectural Protocol implementation as defined in Tiano +# Architecture Specification. This driver has limited functionality +# at runtime and will not log to Data Hub at runtime. +# 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. +# +# +#**/ + +################################################################################ +# +# Defines Section - statements that will be processed to create a Makefile. +# +################################################################################ +[Defines] + INF_VERSION = 0x00010005 + BASE_NAME = DxeStatusCode + FILE_GUID = FEDE0A1B-BCA2-4A9F-BB2B-D9FD7DEC2E9F + MODULE_TYPE = DXE_RUNTIME_DRIVER + VERSION_STRING = 1.0 + EDK_RELEASE_VERSION = 0x00020000 + EFI_SPECIFICATION_VERSION = 0x00020000 + + ENTRY_POINT = InitializeDxeStatusCode + +# +# The following information is for reference only and not required by the build tools. +# +# VALID_ARCHITECTURES = IA32 X64 EBC +# +# VIRTUAL_ADDRESS_MAP_CALLBACK = VirtualAddressChangeCallBack +# + +################################################################################ +# +# Sources Section - list of files that are required for the build to succeed. +# +################################################################################ + +[Sources.common] + SerialStatusCodeWorker.c + RtMemoryStatusCodeWorker.c + DataHubStatusCodeWorker.c + DxeStatusCode.c + DxeStatusCode.h + CommonHeader.h + EntryPoint.c + +[Sources.Ia32] + Common/StatusCode.dxs + Common/DxeStatusCodeCommon.c + +[Sources.X64] + Common/StatusCode.dxs + Common/DxeStatusCodeCommon.c + +[Sources.EBC] + Common/StatusCode.dxs + Common/DxeStatusCodeCommon.c + + +################################################################################ +# +# Includes Section - list of Include locations that are required for +# this module. +# +################################################################################ + +[Includes] + $(WORKSPACE)/MdePkg/Include/Library + $(WORKSPACE)/IntelFrameworkModulePkg/Include + $(WORKSPACE)/IntelFrameworkModulePkg/Include/Library + +################################################################################ +# +# Package Dependency Section - list of Package files that are required for +# this module. +# +################################################################################ + +[Packages] + MdePkg/MdePkg.dec + IntelFrameworkPkg/IntelFrameworkPkg.dec + IntelFrameworkModulePkg/IntelFrameworkModulePkg.dec + +################################################################################ +# +# Library Class Section - list of Library Classes that are required for +# this module. +# +################################################################################ + +[LibraryClasses] + OemHookStatusCodeLib + SerialPortLib + UefiRuntimeLib + MemoryAllocationLib + UefiLib + UefiBootServicesTableLib + UefiDriverEntryPoint + HobLib + PcdLib + PrintLib + ReportStatusCodeLib + DebugLib + BaseMemoryLib + BaseLib + + +################################################################################ +# +# Guid C Name Section - list of Guids that this module uses or produces. +# +################################################################################ + +[Guids] + gEfiStatusCodeGuid # SOMETIMES_CONSUMED + gMemoryStatusCodeRecordGuid # SOMETIMES_CONSUMED + gEfiStatusCodeDataTypeStringGuid # SOMETIMES_CONSUMED + gEfiStatusCodeSpecificDataGuid # SOMETIMES_CONSUMED + +################################################################################ +# +# Protocol C Name Section - list of Protocol and Protocol Notify C Names +# that this module uses or produces. +# +################################################################################ + +[Protocols] + gEfiStatusCodeRuntimeProtocolGuid # PROTOCOL ALWAYS_CONSUMED + gEfiDataHubProtocolGuid # PROTOCOL ALWAYS_CONSUMED + gEfiSerialIoProtocolGuid # PROTOCOL ALWAYS_CONSUMED + + +################################################################################ +# +# Pcd FEATURE_FLAG - list of PCDs that this module is coded for. +# +################################################################################ + +[PcdsFeatureFlag.common] + PcdStatusCodeReplayInOEM|gEfiIntelFrameworkModulePkgTokenSpaceGuid + PcdStatusCodeReplayInRuntimeMemory|gEfiIntelFrameworkModulePkgTokenSpaceGuid + PcdStatusCodeReplayInDataHub|gEfiIntelFrameworkModulePkgTokenSpaceGuid + PcdStatusCodeReplayInSerial|gEfiIntelFrameworkModulePkgTokenSpaceGuid + PcdStatusCodeUseOEM|gEfiIntelFrameworkModulePkgTokenSpaceGuid + PcdStatusCodeUseDataHub|gEfiIntelFrameworkModulePkgTokenSpaceGuid + PcdStatusCodeUseRuntimeMemory|gEfiIntelFrameworkModulePkgTokenSpaceGuid + PcdStatusCodeUseEfiSerial|gEfiIntelFrameworkModulePkgTokenSpaceGuid + PcdStatusCodeUseHardSerial|gEfiIntelFrameworkModulePkgTokenSpaceGuid + + +################################################################################ +# +# Pcd DYNAMIC - list of PCDs that this module is coded for. +# +################################################################################ + +[PcdsDynamic.common] + PcdStatusCodeRuntimeMemorySize|gEfiIntelFrameworkModulePkgTokenSpaceGuid + diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.msa b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.msa new file mode 100644 index 0000000000..5935bdd8f5 --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/DxeStatusCode.msa @@ -0,0 +1,184 @@ + + + + DxeStatusCode + DXE_RUNTIME_DRIVER + FEDE0A1B-BCA2-4A9F-BB2B-D9FD7DEC2E9F + 1.0 + DXE status code driver. + + Status Code Architectural Protocol implementation as defined in Tiano + Architecture Specification. This driver has limited functionality + at runtime and will not log to Data Hub at runtime. + + 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. + FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052 + + + IA32 X64 IPF EBC + false + DxeStatusCode + + + + BaseLib + + + BaseMemoryLib + + + DebugLib + + + ReportStatusCodeLib + + + PrintLib + + + PcdLib + + + HobLib + + + UefiDriverEntryPoint + + + UefiBootServicesTableLib + + + UefiLib + + + MemoryAllocationLib + + + UefiRuntimeLib + + + SerialPortLib + + + OemHookStatusCodeLib + + + EdkDxeSalLib + + + + DxeStatusCode.h + DxeStatusCode.c + DataHubStatusCodeWorker.c + RtMemoryStatusCodeWorker.c + SerialStatusCodeWorker.c + Common/DxeStatusCodeCommon.c + Common/StatusCode.dxs + Common/DxeStatusCodeCommon.c + Common/StatusCode.dxs + Common/DxeStatusCodeCommon.c + Common/StatusCode.dxs + Ipf/DxeStatusCodeIpf.c + Ipf/StatusCode.dxs + + + + + + + + gEfiExtendedSalStatusCodeServicesProtocolGuid + + + gEfiSerialIoProtocolGuid + + + gEfiDataHubProtocolGuid + + + gEfiStatusCodeRuntimeProtocolGuid + + + + + gMemoryStatusCodeRecordGuid + + + gEfiStatusCodeDataTypeStringGuid + + + gEfiStatusCodeSpecificDataGuid + + + gEfiStatusCodeGuid + + + + EFI_SPECIFICATION_VERSION 0x00020000 + EDK_RELEASE_VERSION 0x00020000 + + DxeStatusCodeDriverEntry + + + VirtualAddressChangeCallBack + + + + + PcdStatusCodeUseHardSerial + gEfiEdkModulePkgTokenSpaceGuid + + + + PcdStatusCodeUseEfiSerial + gEfiEdkModulePkgTokenSpaceGuid + + + + PcdStatusCodeUseRuntimeMemory + gEfiEdkModulePkgTokenSpaceGuid + + + + PcdStatusCodeUseDataHub + gEfiEdkModulePkgTokenSpaceGuid + + + + PcdStatusCodeUseOEM + gEfiEdkModulePkgTokenSpaceGuid + + + + PcdStatusCodeReplayInSerial + gEfiEdkModulePkgTokenSpaceGuid + + + + PcdStatusCodeReplayInDataHub + gEfiEdkModulePkgTokenSpaceGuid + + + + PcdStatusCodeReplayInRuntimeMemory + gEfiEdkModulePkgTokenSpaceGuid + + + + PcdStatusCodeReplayInOEM + gEfiEdkModulePkgTokenSpaceGuid + + + + PcdStatusCodeRuntimeMemorySize + gEfiEdkModulePkgTokenSpaceGuid + + + + \ No newline at end of file diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/EntryPoint.c b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/EntryPoint.c new file mode 100644 index 0000000000..46450f364d --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/EntryPoint.c @@ -0,0 +1,59 @@ +/**@file + Entry Point Source file. + + This file contains the user entry point + + 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. +**/ + +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +// +// Event for Exit Boot Services Callback +// +STATIC EFI_EVENT mExitBootServicesEvent = NULL; + +/** + The user Entry Point for module DxeStatusCode. The user code starts with this function. + + @param[in] ImageHandle The firmware allocated handle for the EFI image. + @param[in] SystemTable A pointer to the EFI System Table. + + @retval EFI_SUCCESS The entry point is executed successfully. + @retval other Some error occurs when executing this entry point. + +**/ +EFI_STATUS +EFIAPI +InitializeDxeStatusCode( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +{ + EFI_STATUS Status; + + Status = gBS->CreateEvent ( + EVT_SIGNAL_EXIT_BOOT_SERVICES, + TPL_NOTIFY, + VirtualAddressChangeCallBack, + NULL, + &mExitBootServicesEvent + ); + ASSERT_EFI_ERROR (Status); + + // + // Call the original Entry Point + // + Status = DxeStatusCodeDriverEntry (ImageHandle, SystemTable); + + return Status; +} diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/RtMemoryStatusCodeWorker.c b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/RtMemoryStatusCodeWorker.c new file mode 100644 index 0000000000..db0f103a8a --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/RtMemoryStatusCodeWorker.c @@ -0,0 +1,125 @@ +/** @file + Runtime memory status code worker in DXE. + + 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: RtMemoryStatusCodeWorker.c + +**/ + +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +#include "DxeStatusCode.h" + +/** + Initialize runtime memory status code. + + @return The function always return EFI_SUCCESS + +**/ +EFI_STATUS +RtMemoryStatusCodeInitializeWorker ( + VOID + ) +{ + RUNTIME_MEMORY_STATUSCODE_HEADER *RtMemoryStatusCodeTable; + + // + // Allocate runtime memory status code pool. + // + RtMemoryStatusCodeTable = + (RUNTIME_MEMORY_STATUSCODE_HEADER *) AllocatePool ( + sizeof (RUNTIME_MEMORY_STATUSCODE_HEADER) + + PcdGet16 (PcdStatusCodeRuntimeMemorySize) * + 1024 + ); + + ASSERT (NULL != RtMemoryStatusCodeTable); + + RtMemoryStatusCodeTable->RecordIndex = 0; + RtMemoryStatusCodeTable->NumberOfRecords = 0; + RtMemoryStatusCodeTable->MaxRecordsNumber = + (PcdGet16 (PcdStatusCodeRuntimeMemorySize) * 1024) / sizeof (MEMORY_STATUSCODE_RECORD); + + gDxeStatusCode.RtMemoryStatusCodeTable[PHYSICAL_MODE] = RtMemoryStatusCodeTable; + return EFI_SUCCESS; +} + + +/** + Report status code into runtime memory. If the runtime pool is full, roll back to the + first record and overwrite it. + + @param RtMemoryStatusCodeTable + Point to Runtime memory table header. + + @param CodeType Indicates the type of status code being reported. Type EFI_STATUS_CODE_TYPE is defined in "Related Definitions" below. + + @param Value Describes the current status of a hardware or software entity. + This included information about the class and subclass that is used to classify the entity + as well as an operation. For progress codes, the operation is the current activity. + For error codes, it is the exception. For debug codes, it is not defined at this time. + Type EFI_STATUS_CODE_VALUE is defined in "Related Definitions" below. + Specific values are discussed in the Intel? Platform Innovation Framework for EFI Status Code Specification. + + @param Instance The enumeration of a hardware or software entity within the system. + A system may contain multiple entities that match a class/subclass pairing. + The instance differentiates between them. An instance of 0 indicates that instance information is unavailable, + not meaningful, or not relevant. Valid instance numbers start with 1. + + @return The function always return EFI_SUCCESS. + +**/ +EFI_STATUS +RtMemoryStatusCodeReportWorker ( + RUNTIME_MEMORY_STATUSCODE_HEADER *RtMemoryStatusCodeTable, + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance + ) +{ + MEMORY_STATUSCODE_RECORD *Record; + + ASSERT (NULL != RtMemoryStatusCodeTable); + + // + // Locate current record buffer. + // + Record = (MEMORY_STATUSCODE_RECORD *) (RtMemoryStatusCodeTable + 1); + Record = &Record[RtMemoryStatusCodeTable->RecordIndex++]; + + // + // Save status code. + // + Record->CodeType = CodeType; + Record->Value = Value; + Record->Instance = Instance; + + // + // Record total number of records, we compare the number with max records number, + // if it is bigger than the max number, then the roll back had happened, the record index points to + // the first record. if it is less then max number, then the zero index is the first record. + // + RtMemoryStatusCodeTable->NumberOfRecords++; + if (RtMemoryStatusCodeTable->RecordIndex == RtMemoryStatusCodeTable->MaxRecordsNumber) { + // + // Roll back record index. + // + RtMemoryStatusCodeTable->RecordIndex = 0; + } + + return EFI_SUCCESS; +} + + + diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/SerialStatusCodeWorker.c b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/SerialStatusCodeWorker.c new file mode 100644 index 0000000000..efc8f380a1 --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Dxe/SerialStatusCodeWorker.c @@ -0,0 +1,228 @@ + +/** @file + Serial I/O status code reporting worker. + + 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: SerialStatusCodeWorker.c + +**/ + +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +#include "DxeStatusCode.h" + +STATIC +EFI_SERIAL_IO_PROTOCOL *mSerialIoProtocol; + +/** + Initialize serial status code worker. + + @return The function always return EFI_SUCCESS + +**/ +EFI_STATUS +EfiSerialStatusCodeInitializeWorker ( + VOID + ) +{ + EFI_STATUS Status; + + Status = gBS->LocateProtocol ( + &gEfiSerialIoProtocolGuid, + NULL, + (VOID **) &mSerialIoProtocol + ); + + ASSERT_EFI_ERROR (Status); + + return EFI_SUCCESS; +} + + +/** + Convert status code value and extended data to readable ASCII string, send string to serial I/O device. + + @param CodeType Indicates the type of status code being reported. Type EFI_STATUS_CODE_TYPE is defined in "Related Definitions" below. + + @param Value Describes the current status of a hardware or software entity. + This included information about the class and subclass that is used to classify the entity + as well as an operation. For progress codes, the operation is the current activity. + For error codes, it is the exception. For debug codes, it is not defined at this time. + Type EFI_STATUS_CODE_VALUE is defined in "Related Definitions" below. + Specific values are discussed in the Intel? Platform Innovation Framework for EFI Status Code Specification. + + @param Instance The enumeration of a hardware or software entity within the system. + A system may contain multiple entities that match a class/subclass pairing. + The instance differentiates between them. An instance of 0 indicates that instance information is unavailable, + not meaningful, or not relevant. Valid instance numbers start with 1. + + + @param CallerId This optional parameter may be used to identify the caller. + This parameter allows the status code driver to apply different rules to different callers. + Type EFI_GUID is defined in InstallProtocolInterface() in the EFI 1.10 Specification. + + + @param Data This optional parameter may be used to pass additional data + + @retval EFI_SUCCESS Success to report status code to serial I/O. + @retval EFI_DEVICE_ERROR EFI serial device can not work after ExitBootService() is called . + +**/ +EFI_STATUS +SerialStatusCodeReportWorker ( + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN EFI_GUID *CallerId, + IN EFI_STATUS_CODE_DATA *Data OPTIONAL + ) +{ + CHAR8 *Filename; + CHAR8 *Description; + CHAR8 *Format; + CHAR8 Buffer[EFI_STATUS_CODE_DATA_MAX_SIZE]; + UINT32 ErrorLevel; + UINT32 LineNumber; + UINTN CharCount; + VA_LIST Marker; + EFI_DEBUG_INFO *DebugInfo; + EFI_TPL CurrentTpl; + + + if (FeaturePcdGet (PcdStatusCodeUseEfiSerial)) { + if (EfiAtRuntime ()) { + return EFI_DEVICE_ERROR; + } + CurrentTpl = gBS->RaiseTPL (TPL_HIGH_LEVEL); + gBS->RestoreTPL (CurrentTpl); + + if (CurrentTpl > TPL_CALLBACK ) { + return EFI_DEVICE_ERROR; + } + } + + Buffer[0] = '\0'; + + if (Data != NULL && + ReportStatusCodeExtractAssertInfo (CodeType, Value, Data, &Filename, &Description, &LineNumber)) { + // + // Print ASSERT() information into output buffer. + // + CharCount = AsciiSPrint ( + Buffer, + EFI_STATUS_CODE_DATA_MAX_SIZE, + "\n\rDXE_ASSERT!: %a (%d): %a\n\r", + Filename, + LineNumber, + Description + ); + } else if (Data != NULL && + ReportStatusCodeExtractDebugInfo (Data, &ErrorLevel, &Marker, &Format)) { + // + // Print DEBUG() information into output buffer. + // + CharCount = AsciiVSPrint ( + Buffer, + EFI_STATUS_CODE_DATA_MAX_SIZE, + Format, + Marker + ); + } else if (Data != NULL && + CompareGuid (&Data->Type, &gEfiStatusCodeSpecificDataGuid) && + (CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_DEBUG_CODE) { + // + // Print specific data into output buffer. + // + DebugInfo = (EFI_DEBUG_INFO *) (Data + 1); + Marker = (VA_LIST) (DebugInfo + 1); + Format = (CHAR8 *) (((UINT64 *) Marker) + 12); + + CharCount = AsciiVSPrint (Buffer, EFI_STATUS_CODE_DATA_MAX_SIZE, Format, Marker); + } else if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_ERROR_CODE) { + // + // Print ERROR information into output buffer. + // + CharCount = AsciiSPrint ( + Buffer, + EFI_STATUS_CODE_DATA_MAX_SIZE, + "ERROR: C%x:V%x I%x", + CodeType, + Value, + Instance + ); + + // + // Make sure we don't try to print values that weren't + // intended to be printed, especially NULL GUID pointers. + // + + if (CallerId != NULL) { + CharCount += AsciiSPrint ( + &Buffer[CharCount - 1], + (EFI_STATUS_CODE_DATA_MAX_SIZE - (sizeof (Buffer[0]) * CharCount)), + " %g", + CallerId + ); + } + + if (Data != NULL) { + CharCount += AsciiSPrint ( + &Buffer[CharCount - 1], + (EFI_STATUS_CODE_DATA_MAX_SIZE - (sizeof (Buffer[0]) * CharCount)), + " %x", + Data + ); + } + + CharCount += AsciiSPrint ( + &Buffer[CharCount - 1], + (EFI_STATUS_CODE_DATA_MAX_SIZE - (sizeof (Buffer[0]) * CharCount)), + "\n\r" + ); + } else if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_PROGRESS_CODE) { + CharCount = AsciiSPrint ( + Buffer, + EFI_STATUS_CODE_DATA_MAX_SIZE, + "PROGRESS CODE: V%x I%x\n\r", + Value, + Instance + ); + } else { + CharCount = AsciiSPrint ( + Buffer, + EFI_STATUS_CODE_DATA_MAX_SIZE, + "Undefined: C%x:V%x I%x\n\r", + CodeType, + Value, + Instance + ); + } + + + if (FeaturePcdGet (PcdStatusCodeUseHardSerial)) { + // + // Callout to SerialPort Lib function to do print. + // + SerialPortWrite ((UINT8 *) Buffer, CharCount); + } + if (FeaturePcdGet (PcdStatusCodeUseEfiSerial)) { + mSerialIoProtocol->Write ( + mSerialIoProtocol, + &CharCount, + Buffer + ); + } + + return EFI_SUCCESS; +} diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Pei/CommonHeader.h b/IntelFrameworkModulePkg/Universal/StatusCode/Pei/CommonHeader.h new file mode 100644 index 0000000000..2521548f6f --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Pei/CommonHeader.h @@ -0,0 +1,44 @@ +/**@file + Common header file shared by all source files. + + This file includes package header files, library classes and protocol, PPI & GUID definitions. + + Copyright (c) 2006, Intel Corporation. + All rights reserved. This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +**/ + +#ifndef __COMMON_HEADER_H_ +#define __COMMON_HEADER_H_ + + +// +// The package level header files this module uses +// +#include +// +// The protocols, PPI and GUID defintions for this module +// +#include +#include +#include +// +// The Library classes this module consumes +// +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Pei/MemoryStausCodeWorker.c b/IntelFrameworkModulePkg/Universal/StatusCode/Pei/MemoryStausCodeWorker.c new file mode 100644 index 0000000000..195e3e2183 --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Pei/MemoryStausCodeWorker.c @@ -0,0 +1,156 @@ +/** @file + Memory status code worker in PEI. + + 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: MemoryStatusCodeWorker.c + +**/ + +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +#include "PeiStatusCode.h" + +/** + Create one memory status code GUID'ed HOB, use PacketIndex + to identify the packet. + + @param PacketIndex Index of records packet. + + @return Always return pointer of memory status code packet. + +**/ +STATIC +MEMORY_STATUSCODE_PACKET_HEADER * +CreateMemoryStatusCodePacket ( + UINT16 PacketIndex + ) +{ + MEMORY_STATUSCODE_PACKET_HEADER *PacketHeader; + + // + // Build GUID'ed HOB with PCD defined size. + // + PacketHeader = + (MEMORY_STATUSCODE_PACKET_HEADER *) BuildGuidHob ( + &gMemoryStatusCodeRecordGuid, + PcdGet16 (PcdStatusCodeMemorySize) * + 1024 + + sizeof (MEMORY_STATUSCODE_PACKET_HEADER) + ); + ASSERT (PacketHeader != NULL); + + PacketHeader->MaxRecordsNumber = (PcdGet16 (PcdStatusCodeMemorySize) * 1024)/ sizeof (MEMORY_STATUSCODE_RECORD); + PacketHeader->PacketIndex = PacketIndex; + PacketHeader->RecordIndex = 0; + + return PacketHeader; +} + + + +/** + Initialize memory status code. + Create one GUID'ed HOB with PCD defined size. If create required size + GUID'ed HOB failed, then ASSERT(). + + @return The function always return EFI_SUCCESS + +**/ +EFI_STATUS +MemoryStatusCodeInitializeWorker ( + VOID + ) +{ + // + // Create first memory status code GUID'ed HOB. + // + CreateMemoryStatusCodePacket (0); + + return EFI_SUCCESS; +} + + +/** + Report status code into GUID'ed HOB.. + + @param CodeType Indicates the type of status code being reported. Type EFI_STATUS_CODE_TYPE is defined in "Related Definitions" below. + + @param Value Describes the current status of a hardware or software entity. + This included information about the class and subclass that is used to classify the entity + as well as an operation. For progress codes, the operation is the current activity. + For error codes, it is the exception. For debug codes, it is not defined at this time. + Type EFI_STATUS_CODE_VALUE is defined in "Related Definitions" below. + Specific values are discussed in the Intel? Platform Innovation Framework for EFI Status Code Specification. + + @param Instance The enumeration of a hardware or software entity within the system. + A system may contain multiple entities that match a class/subclass pairing. + The instance differentiates between them. An instance of 0 indicates that instance information is unavailable, + not meaningful, or not relevant. Valid instance numbers start with 1. + + @return The function always return EFI_SUCCESS. + +**/ +EFI_STATUS +MemoryStatusCodeReportWorker ( + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance + ) +{ + + EFI_PEI_HOB_POINTERS Hob; + MEMORY_STATUSCODE_PACKET_HEADER *PacketHeader; + MEMORY_STATUSCODE_RECORD *Record = NULL; + UINT16 PacketIndex = 0;; + + // + // Journal GUID'ed HOBs to find empty record entry, if found, then save status code in it. + // otherwise, create a new GUID'ed HOB. + // + Hob.Raw = GetFirstGuidHob (&gMemoryStatusCodeRecordGuid); + while (Hob.Raw != NULL) { + PacketHeader = (MEMORY_STATUSCODE_PACKET_HEADER *) GET_GUID_HOB_DATA (Hob.Guid); + + // + // Check whether pccket is full or not. + // + if (PacketHeader->RecordIndex < PacketHeader->MaxRecordsNumber) { + Record = (MEMORY_STATUSCODE_RECORD *) (PacketHeader + 1); + Record = &Record[PacketHeader->RecordIndex++]; + break; + } + // + // Cache number of found packet in PacketIndex. + // + PacketIndex++; + + Hob.Raw = GetNextGuidHob (&gMemoryStatusCodeRecordGuid, Hob.Raw); + } + + if (NULL == Record) { + // + // In order to save status code , create new packet. + // + PacketHeader = CreateMemoryStatusCodePacket (PacketIndex); + + Record = (MEMORY_STATUSCODE_RECORD *) (PacketHeader + 1); + Record = &Record[PacketHeader->RecordIndex++]; + } + + Record->CodeType = CodeType; + Record->Instance = Instance; + Record->Value = Value; + + return EFI_SUCCESS; +} diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.c b/IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.c new file mode 100644 index 0000000000..0a697cc211 --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.c @@ -0,0 +1,151 @@ + +/** @file + Generic PeiStatusCode Module. + + 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: PeiStatusCode.c + +**/ + +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +#include "PeiStatusCode.h" + +STATIC +EFI_PEI_PROGRESS_CODE_PPI mStatusCodePpi = { + ReportDispatcher + }; + +STATIC +EFI_PEI_PPI_DESCRIPTOR mStatusCodePpiDescriptor = { + EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST, + &gEfiPeiStatusCodePpiGuid, + &mStatusCodePpi + }; + +/** + Report status code to all supported device. + + + @param PeiServices + + @param CodeType Indicates the type of status code being reported. + The type EFI_STATUS_CODE_TYPE is defined in "Related Definitions" below. + @param Value Describes the current status of a hardware or software entity. + This includes information about the class and subclass that is used to classify the entity + as well as an operation. For progress codes, the operation is the current activity. + For error codes, it is the exception. For debug codes, it is not defined at this time. + Type EFI_STATUS_CODE_VALUE is defined in "Related Definitions" below. + Specific values are discussed in the Intel? Platform Innovation Framework for EFI Status Code Specification. + @param Instance The enumeration of a hardware or software entity within the system. + A system may contain multiple entities that match a class/subclass pairing. + The instance differentiates between them. An instance of 0 indicates that instance + information is unavailable, not meaningful, or not relevant. Valid instance numbers start with 1. + @param CallerId This optional parameter may be used to identify the caller. + This parameter allows the status code driver to apply different rules to different callers. + @param Data This optional parameter may be used to pass additional data. + Type EFI_STATUS_CODE_DATA is defined in "Related Definitions" below. + The contents of this data type may have additional GUID-specific data. The standard GUIDs and + their associated data structures are defined in the Intel? Platform Innovation Framework for EFI Status Codes Specification. + + @return Always return EFI_SUCCESS. + +**/ +EFI_STATUS +EFIAPI +ReportDispatcher ( + IN EFI_PEI_SERVICES **PeiServices, + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN EFI_GUID *CallerId OPTIONAL, + IN EFI_STATUS_CODE_DATA *Data OPTIONAL + ) +{ + if (FeaturePcdGet (PcdStatusCodeUseSerial)) { + SerialStatusCodeReportWorker ( + CodeType, + Value, + Instance, + CallerId, + Data + ); + } + if (FeaturePcdGet (PcdStatusCodeUseMemory)) { + MemoryStatusCodeReportWorker ( + CodeType, + Value, + Instance + ); + } + if (FeaturePcdGet (PcdStatusCodeUseOEM)) { + OemHookStatusCodeReport ( + CodeType, + Value, + Instance, + CallerId, + Data + ); + } + + return EFI_SUCCESS; +} + +/** + Initialize PEI status codes and publish the status code + PPI. + + @param FfsHeader FV this PEIM was loaded from. + @param PeiServices General purpose services available to every PEIM. + + @return The function always returns success. + +**/ +EFI_STATUS +PeiStatusCodeDriverEntry ( + IN EFI_FFS_FILE_HEADER *FfsHeader, + IN EFI_PEI_SERVICES **PeiServices + ) +{ + EFI_STATUS Status; + + // + // Dispatch initialization request to sub-statuscode-devices. + // If enable UseSerial, then initialize serial port. + // if enable UseMemory, then initialize memory status code worker. + // if enable UseOEM, then initialize Oem status code. + // + if (FeaturePcdGet (PcdStatusCodeUseSerial)) { + Status = SerialPortInitialize(); + ASSERT_EFI_ERROR (Status); + } + if (FeaturePcdGet (PcdStatusCodeUseMemory)) { + Status = MemoryStatusCodeInitializeWorker (); + ASSERT_EFI_ERROR (Status); + } + if (FeaturePcdGet (PcdStatusCodeUseOEM)) { + Status = OemHookStatusCodeInitialize (); + ASSERT_EFI_ERROR (Status); + } + + // + // Install PeiStatusCodePpi. + // PeiServices use this Ppi to output status code. + // use library + Status = PeiServicesInstallPpi (&mStatusCodePpiDescriptor); + ASSERT_EFI_ERROR (Status); + + return EFI_SUCCESS; +} + diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.h b/IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.h new file mode 100644 index 0000000000..c8c004d6cd --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.h @@ -0,0 +1,144 @@ + +/** @file + Heade file of status code PEIM + + 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: PeiStatusCode.h + +**/ + +#ifndef __PEI_STATUS_CODE_H__ +#define __PEI_STATUS_CODE_H__ + + +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +/** + Convert status code value and extended data to readable ASCII string, send string to serial I/O device. + + @param CodeType Indicates the type of status code being reported. Type EFI_STATUS_CODE_TYPE is defined in "Related Definitions" below. + + @param Value Describes the current status of a hardware or software entity. + This included information about the class and subclass that is used to classify the entity + as well as an operation. For progress codes, the operation is the current activity. + For error codes, it is the exception. For debug codes, it is not defined at this time. + Type EFI_STATUS_CODE_VALUE is defined in "Related Definitions" below. + Specific values are discussed in the Intel? Platform Innovation Framework for EFI Status Code Specification. + + @param Instance The enumeration of a hardware or software entity within the system. + A system may contain multiple entities that match a class/subclass pairing. + The instance differentiates between them. An instance of 0 indicates that instance information is unavailable, + not meaningful, or not relevant. Valid instance numbers start with 1. + + + @param CallerId This optional parameter may be used to identify the caller. + This parameter allows the status code driver to apply different rules to different callers. + Type EFI_GUID is defined in InstallProtocolInterface() in the EFI 1.10 Specification. + + + @param Data This optional parameter may be used to pass additional data + + @return The function always return EFI_SUCCESS. + +**/ +EFI_STATUS +SerialStatusCodeReportWorker ( + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN EFI_GUID *CallerId, + IN EFI_STATUS_CODE_DATA *Data OPTIONAL + ); + + +/** + Initialize memory status code. + Create one GUID'ed HOB with PCD defined size. If create required size + GUID'ed HOB failed, then ASSERT(). + + @return The function always return EFI_SUCCESS + +**/ +EFI_STATUS +MemoryStatusCodeInitializeWorker ( + VOID + ); + +/** + Report status code into GUID'ed HOB. + + @param CodeType Indicates the type of status code being reported. Type EFI_STATUS_CODE_TYPE is defined in "Related Definitions" below. + + @param Value Describes the current status of a hardware or software entity. + This included information about the class and subclass that is used to classify the entity + as well as an operation. For progress codes, the operation is the current activity. + For error codes, it is the exception. For debug codes, it is not defined at this time. + Type EFI_STATUS_CODE_VALUE is defined in "Related Definitions" below. + Specific values are discussed in the Intel? Platform Innovation Framework for EFI Status Code Specification. + + @param Instance The enumeration of a hardware or software entity within the system. + A system may contain multiple entities that match a class/subclass pairing. + The instance differentiates between them. An instance of 0 indicates that instance information is unavailable, + not meaningful, or not relevant. Valid instance numbers start with 1. + + @return The function always return EFI_SUCCESS. + +**/ +EFI_STATUS +MemoryStatusCodeReportWorker ( + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance + ); + +/** + Report status code to all supported device. + + + @param PeiServices + + @param Type Indicates the type of status code being reported. + The type EFI_STATUS_CODE_TYPE is defined in "Related Definitions" below. + @param Value Describes the current status of a hardware or software entity. + This includes information about the class and subclass that is used to classify the entity + as well as an operation. For progress codes, the operation is the current activity. + For error codes, it is the exception. For debug codes, it is not defined at this time. + Type EFI_STATUS_CODE_VALUE is defined in "Related Definitions" below. + Specific values are discussed in the Intel? Platform Innovation Framework for EFI Status Code Specification. + @param Instance The enumeration of a hardware or software entity within the system. + A system may contain multiple entities that match a class/subclass pairing. + The instance differentiates between them. An instance of 0 indicates that instance + information is unavailable, not meaningful, or not relevant. Valid instance numbers start with 1. + @param CallerId This optional parameter may be used to identify the caller. + This parameter allows the status code driver to apply different rules to different callers. + @param Data This optional parameter may be used to pass additional data. + Type EFI_STATUS_CODE_DATA is defined in "Related Definitions" below. + The contents of this data type may have additional GUID-specific data. The standard GUIDs and + their associated data structures are defined in the Intel? Platform Innovation Framework for EFI Status Codes Specification. + + @return Always return EFI_SUCCESS. + +**/ +EFI_STATUS +EFIAPI +ReportDispatcher ( + IN EFI_PEI_SERVICES **PeiServices, + IN EFI_STATUS_CODE_TYPE Type, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN EFI_GUID *CallerId OPTIONAL, + IN EFI_STATUS_CODE_DATA *Data OPTIONAL + ); + +#endif diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.inf b/IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.inf new file mode 100644 index 0000000000..2812509df2 --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.inf @@ -0,0 +1,140 @@ +#/** @file +# Generic Status code Pei driver +# +# Customized output devices based on feature flags. +# 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. +# +# +#**/ + +################################################################################ +# +# Defines Section - statements that will be processed to create a Makefile. +# +################################################################################ +[Defines] + INF_VERSION = 0x00010005 + BASE_NAME = PeiStatusCode + FILE_GUID = 1EC0F53A-FDE0-4576-8F25-7A1A410F58EB + MODULE_TYPE = PEIM + VERSION_STRING = 1.0 + EDK_RELEASE_VERSION = 0x00020000 + EFI_SPECIFICATION_VERSION = 0x00020000 + + ENTRY_POINT = PeiStatusCodeDriverEntry + +# +# The following information is for reference only and not required by the build tools. +# +# VALID_ARCHITECTURES = IA32 X64 IPF EBC +# + +################################################################################ +# +# Sources Section - list of files that are required for the build to succeed. +# +################################################################################ + +[Sources.common] + PeiStatusCode.c + MemoryStausCodeWorker.c + SerialStatusCodeWorker.c + PeiStatusCode.h + CommonHeader.h + + +################################################################################ +# +# Includes Section - list of Include locations that are required for +# this module. +# +################################################################################ + +[Includes] + $(WORKSPACE)/MdePkg/Include/Library + $(WORKSPACE)/IntelFrameworkPkg/Include + $(WORKSPACE)/IntelFrameworkModulePkg/Include + $(WORKSPACE)/IntelFrameworkModulePkg/Include/Library + +################################################################################ +# +# Package Dependency Section - list of Package files that are required for +# this module. +# +################################################################################ + +[Packages] + MdePkg/MdePkg.dec + IntelFrameworkPkg/IntelFrameworkPkg.dec + IntelFrameworkModulePkg/IntelFrameworkModulePkg.dec + +################################################################################ +# +# Library Class Section - list of Library Classes that are required for +# this module. +# +################################################################################ + +[LibraryClasses] + PeimEntryPoint + OemHookStatusCodeLib + PeiServicesLib + PcdLib + HobLib + SerialPortLib + ReportStatusCodeLib + PrintLib + DebugLib + BaseMemoryLib + BaseLib + + +################################################################################ +# +# Guid C Name Section - list of Guids that this module uses or produces. +# +################################################################################ + +[Guids] + gMemoryStatusCodeRecordGuid # SOMETIMES_CONSUMED + + +################################################################################ +# +# PPI C Name Section - list of PPI and PPI Notify C Names that this module +# uses or produces. +# +################################################################################ + +[Ppis] + gEfiPeiStatusCodePpiGuid # PPI ALWAYS_CONSUMED + + +################################################################################ +# +# Pcd FEATURE_FLAG - list of PCDs that this module is coded for. +# +################################################################################ + +[PcdsFeatureFlag.common] + PcdStatusCodeUseOEM|gEfiIntelFrameworkModulePkgTokenSpaceGuid + PcdStatusCodeUseMemory|gEfiIntelFrameworkModulePkgTokenSpaceGuid + PcdStatusCodeUseSerial|gEfiIntelFrameworkModulePkgTokenSpaceGuid + + +################################################################################ +# +# Pcd DYNAMIC - list of PCDs that this module is coded for. +# +################################################################################ + +[PcdsDynamic.common] + PcdStatusCodeMemorySize|gEfiIntelFrameworkModulePkgTokenSpaceGuid + diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.msa b/IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.msa new file mode 100644 index 0000000000..d0cd00d7fa --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Pei/PeiStatusCode.msa @@ -0,0 +1,111 @@ + + + + PeiStatusCode + PEIM + 1EC0F53A-FDE0-4576-8F25-7A1A410F58EB + 1.0 + Generic Status code Pei driver + Customized output devices based on feature flags. + 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. + FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052 + + + IA32 X64 IPF EBC + false + PeiStatusCode + + + + BaseLib + + + BaseMemoryLib + + + DebugLib + + + PrintLib + + + ReportStatusCodeLib + + + SerialPortLib + + + HobLib + + + PcdLib + + + PeiServicesLib + + + OemHookStatusCodeLib + + + PeimEntryPoint + + + + PeiStatusCode.h + SerialStatusCodeWorker.c + MemoryStausCodeWorker.c + PeiStatusCode.c + + + + + + + + gEfiPeiStatusCodePpiGuid + + + + + gMemoryStatusCodeRecordGuid + + + gEfiStatusCodeSpecificDataGuid + + + + EFI_SPECIFICATION_VERSION 0x00020000 + EDK_RELEASE_VERSION 0x00020000 + + PeiStatusCodeDriverEntry + + + + + PcdStatusCodeUseSerial + gEfiEdkModulePkgTokenSpaceGuid + + + + PcdStatusCodeUseMemory + gEfiEdkModulePkgTokenSpaceGuid + + + + PcdStatusCodeUseOEM + gEfiEdkModulePkgTokenSpaceGuid + + + + PcdStatusCodeMemorySize + gEfiEdkModulePkgTokenSpaceGuid + + + + \ No newline at end of file diff --git a/IntelFrameworkModulePkg/Universal/StatusCode/Pei/SerialStatusCodeWorker.c b/IntelFrameworkModulePkg/Universal/StatusCode/Pei/SerialStatusCodeWorker.c new file mode 100644 index 0000000000..2efc23ceac --- /dev/null +++ b/IntelFrameworkModulePkg/Universal/StatusCode/Pei/SerialStatusCodeWorker.c @@ -0,0 +1,174 @@ + +/** @file + Serial I/O status code reporting worker. + + 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: SerialStatusCodeWorker.c + +**/ + +// +// Include common header file for this module. +// +#include "CommonHeader.h" + +#include "PeiStatusCode.h" + +/** + Convert status code value and extended data to readable ASCII string, send string to serial I/O device. + + @param CodeType Indicates the type of status code being reported. Type EFI_STATUS_CODE_TYPE is defined in "Related Definitions" below. + + @param Value Describes the current status of a hardware or software entity. + This included information about the class and subclass that is used to classify the entity + as well as an operation. For progress codes, the operation is the current activity. + For error codes, it is the exception. For debug codes, it is not defined at this time. + Type EFI_STATUS_CODE_VALUE is defined in "Related Definitions" below. + Specific values are discussed in the Intel? Platform Innovation Framework for EFI Status Code Specification. + + @param Instance The enumeration of a hardware or software entity within the system. + A system may contain multiple entities that match a class/subclass pairing. + The instance differentiates between them. An instance of 0 indicates that instance information is unavailable, + not meaningful, or not relevant. Valid instance numbers start with 1. + + + @param CallerId This optional parameter may be used to identify the caller. + This parameter allows the status code driver to apply different rules to different callers. + Type EFI_GUID is defined in InstallProtocolInterface() in the EFI 1.10 Specification. + + + @param Data This optional parameter may be used to pass additional data + + @return The function always return EFI_SUCCESS. + +**/ +EFI_STATUS +SerialStatusCodeReportWorker ( + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN EFI_GUID *CallerId, + IN EFI_STATUS_CODE_DATA *Data OPTIONAL + ) +{ + CHAR8 *Filename; + CHAR8 *Description; + CHAR8 *Format; + CHAR8 Buffer[EFI_STATUS_CODE_DATA_MAX_SIZE]; + UINT32 ErrorLevel; + UINT32 LineNumber; + UINTN CharCount; + VA_LIST Marker; + EFI_DEBUG_INFO *DebugInfo; + + Buffer[0] = '\0'; + + if (Data != NULL && + ReportStatusCodeExtractAssertInfo (CodeType, Value, Data, &Filename, &Description, &LineNumber)) { + // + // Print ASSERT() information into output buffer. + // + CharCount = AsciiSPrint ( + Buffer, + EFI_STATUS_CODE_DATA_MAX_SIZE, + "\n\rPEI_ASSERT!: %a (%d): %a\n\r", + Filename, + LineNumber, + Description + ); + } else if (Data != NULL && + ReportStatusCodeExtractDebugInfo (Data, &ErrorLevel, &Marker, &Format)) { + // + // Print DEBUG() information into output buffer. + // + CharCount = AsciiVSPrint ( + Buffer, + EFI_STATUS_CODE_DATA_MAX_SIZE, + Format, + Marker + ); + } else if (Data != NULL && + CompareGuid (&Data->Type, &gEfiStatusCodeSpecificDataGuid) && + (CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_DEBUG_CODE) { + // + // Print specific data into output buffer. + // + DebugInfo = (EFI_DEBUG_INFO *) (Data + 1); + Marker = (VA_LIST) (DebugInfo + 1); + Format = (CHAR8 *) (((UINT64 *) Marker) + 12); + + CharCount = AsciiVSPrint (Buffer, EFI_STATUS_CODE_DATA_MAX_SIZE, Format, Marker); + } else if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_ERROR_CODE) { + // + // Print ERROR information into output buffer. + // + CharCount = AsciiSPrint ( + Buffer, + EFI_STATUS_CODE_DATA_MAX_SIZE, + "ERROR: C%x:V%x I%x", + CodeType, + Value, + Instance + ); + + // + // Make sure we don't try to print values that weren't intended to be printed, especially NULL GUID pointers. + // + + if (CallerId != NULL) { + CharCount += AsciiSPrint ( + &Buffer[CharCount - 1], + (EFI_STATUS_CODE_DATA_MAX_SIZE - (sizeof (Buffer[0]) * CharCount)), + " %g", + CallerId + ); + } + + if (Data != NULL) { + CharCount += AsciiSPrint ( + &Buffer[CharCount - 1], + (EFI_STATUS_CODE_DATA_MAX_SIZE - (sizeof (Buffer[0]) * CharCount)), + " %x", + Data + ); + } + + CharCount += AsciiSPrint ( + &Buffer[CharCount - 1], + (EFI_STATUS_CODE_DATA_MAX_SIZE - (sizeof (Buffer[0]) * CharCount)), + "\n\r" + ); + } else if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_PROGRESS_CODE) { + CharCount = AsciiSPrint ( + Buffer, + EFI_STATUS_CODE_DATA_MAX_SIZE, + "PROGRESS CODE: V%x I%x\n\r", + Value, + Instance + ); + } else { + CharCount = AsciiSPrint ( + Buffer, + EFI_STATUS_CODE_DATA_MAX_SIZE, + "Undefined: C%x:V%x I%x\n\r", + CodeType, + Value, + Instance + ); + } + + // + // Callout to SerialPort Lib function to do print. + // + SerialPortWrite ((UINT8 *) Buffer, CharCount); + + return EFI_SUCCESS; +} -- cgit v1.2.3